Merge pull request #2 from jell0nek/master

Added the skipWhile and skipWhile_i LINQ functions

boolinq/SkipWhileRangeTest.cpp

+#include <vector>
+#include <string>
+
+#include <gmock/gmock.h>
+#include <gtest/gtest.h>
+#include "CommonTests.h"
+
+#include "boolinq.h"
+
+using namespace boolinq;
+
+//////////////////////////////////////////////////////////////////////////
+
+TEST(SkipWhileRange, ManyToMore)
+{
+    int src[] = {1,2,3,4,5,6};
+    int ans[] = {1,2,3,4,5,6};
+
+    auto rng = from(src);
+    auto dst = rng.skipWhile([](int it){return it < 0 || it > 10;});
+
+    auto vec = dst.toVector();
+
+    CheckRangeEqArray(dst, ans);
+}
+
+TEST(SkipWhileRange_i, ManyToMoreByIndex)
+{
+    int src[] = {1,2,3,4,5,6};
+    int ans[] = {1,2,3,4,5,6};
+
+    auto rng = from(src);
+    auto dst = rng.skipWhile_i([](int /*it*/, int idx){return idx > 10;});
+
+    CheckRangeEqArray(dst, ans);
+}
+
+TEST(SkipWhileRange_i, ManyToMoreByItemValue)
+{
+    int src[] = {1,2,3,4,5,6};
+    int ans[] = {1,2,3,4,5,6};
+
+    auto rng = from(src);
+    auto dst = rng.skipWhile_i([](int it, int /*idx*/){return it < 0 || it > 10;});
+
+    CheckRangeEqArray(dst, ans);
+}
+
+TEST(SkipWhileRange_i, ManyToMoreByIndexAndItemValue)
+{
+    int src[] = {1,2,3,4,5,6};
+    int ans[] = {1,2,3,4,5,6};
+
+    auto rng = from(src);
+    auto dst = rng.skipWhile_i([](int it, int idx){return idx*it > 0;});
+
+    CheckRangeEqArray(dst, ans);
+}
+
+TEST(SkipWhileRange, ManyToMany)
+{
+    int src[] = {1,2,3,4,5,6};
+    int ans[] = {1,2,3,4,5,6};
+
+    auto rng = from(src);
+    auto dst = rng.skipWhile([](int it){return it < 0 && it > 6;});
+
+    CheckRangeEqArray(dst, ans);
+}
+
+TEST(SkipWhileRange_i, ManyToManyByIndex)
+{
+    int src[] = {1,2,3,4,5,6};
+    int ans[] = {1,2,3,4,5,6};
+
+    auto rng = from(src);
+    auto dst = rng.skipWhile_i([](int /*it*/, int idx){return idx > 5;});
+
+    CheckRangeEqArray(dst, ans);
+}
+
+TEST(SkipWhileRange_i, ManyToManyByItemValue)
+{
+    int src[] = {1,2,3,4,5,6};
+    int ans[] = {1,2,3,4,5,6};
+
+    auto rng = from(src);
+    auto dst = rng.skipWhile_i([](int it, int /*idx*/){return it < 1 || it > 6;});
+
+    CheckRangeEqArray(dst, ans);
+}
+
+TEST(SkipWhileRange_i, ManyToManyByIndexAndItemValue)
+{
+    int src[] = {1,2,3,4,5,6};
+    int ans[] = {1,2,3,4,5,6};
+
+    auto rng = from(src);
+    auto dst = rng.skipWhile_i([](int it, int idx){return idx > 5 || it < 0;});
+
+    CheckRangeEqArray(dst, ans);
+}
+
+
+TEST(SkipWhileRange, ManyToLess)
+{
+    int src[] = {1,2,3,4,5,6};
+    int ans[] = {3,4,5,6};
+
+    auto rng = from(src);
+    auto dst = rng.skipWhile([](int it){return it < 3 || it > 4;});
+
+    CheckRangeEqArray(dst, ans);
+}
+
+TEST(SkipWhileRange_i, ManyToLessByIndex)
+{
+    int src[] = {1,2,3,4,5,6};
+    int ans[] = {4,5,6};
+
+    auto rng = from(src);
+    auto dst = rng.skipWhile_i([](int /*it*/, int idx){return idx < 3 || idx > 3;});
+
+    CheckRangeEqArray(dst, ans);
+}
+
+TEST(SkipWhileRange_i, ManyToLessByItemValue)
+{
+    int src[] = {1,2,3,4,5,6};
+    int ans[] = {3,4,5,6};
+
+    auto rng = from(src);
+    auto dst = rng.skipWhile_i([](int it, int /*idx*/){return it < 3 || it > 4;});
+
+    CheckRangeEqArray(dst, ans);
+}
+
+TEST(SkipWhileRange_i, ManyToLessByIndexAndItemValue)
+{
+    int src[] = {1,2,3,4,5,6};
+    int ans[] = {4,5,6};
+
+    auto rng = from(src);
+    auto dst = rng.skipWhile_i([](int it, int idx){return idx*it < 7;});
+
+    CheckRangeEqArray(dst, ans);
+}
+
+TEST(SkipWhileRange, ManyToOne)
+{
+    int src[] = {1,2,3,4,5,6};
+    int ans[] = {6};
+
+    auto rng = from(src);
+    auto dst = rng.skipWhile([](int it){return it != 6;});
+
+    CheckRangeEqArray(dst, ans);
+}
+
+TEST(SkipWhileRange_i, ManyToOneByIndex)
+{
+    int src[] = {1,2,3,4,5,6};
+    int ans[] = {6};
+
+    auto rng = from(src);
+    auto dst = rng.skipWhile_i([](int /*it*/, int idx){return idx < 5;});
+
+    CheckRangeEqArray(dst, ans);
+}
+
+TEST(SkipWhileRange_i, ManyToOneByItemValue)
+{
+    int src[] = {1,2,3,4,5,6};
+    int ans[] = {6};
+
+    auto rng = from(src);
+    auto dst = rng.skipWhile_i([](int it, int /*idx*/){return it < 6;});
+
+    CheckRangeEqArray(dst, ans);
+}
+
+TEST(SkipWhileRange_i, ManyToOneByIndexAndItemValue)
+{
+    int src[] = {1,2,3,4,5,6};
+    int ans[] = {6};
+
+    auto rng = from(src);
+    auto dst = rng.skipWhile_i([](int it, int idx){return idx*it < 30;});
+
+    CheckRangeEqArray(dst, ans);
+}
+
+TEST(SkipWhileRange, ManyToZero)
+{
+    int src[] = {1,2,3,4,5,6};
+
+    auto rng = from(src);
+    auto dst = rng.skipWhile([](int it){return it > 0;});
+
+    EXPECT_THROW(dst.nextObject(), EnumeratorEndException);
+}
+
+TEST(SkipWhileRange_i, ManyToZeroeByIndex)
+{
+    int src[] = {1,2,3,4,5,6};
+
+    auto rng = from(src);
+    auto dst = rng.skipWhile_i([](int /*it*/, int idx){return idx < 6;});
+
+    EXPECT_THROW(dst.nextObject(), EnumeratorEndException);
+}
+
+TEST(SkipWhileRange_i, ManyToZeroByItemValue)
+{
+    int src[] = {1,2,3,4,5,6};
+
+    auto rng = from(src);
+    auto dst = rng.skipWhile_i([](int it, int /*idx*/){return it > 0;});
+
+    EXPECT_THROW(dst.nextObject(), EnumeratorEndException);
+}
+
+TEST(SkipWhileRange_i, ManyToZeroIndexAndItemValue)
+{
+    int src[] = {1,2,3,4,5,6};
+
+    auto rng = from(src);
+    auto dst = rng.skipWhile_i([](int it, int idx){return idx != it;});
+
+    EXPECT_THROW(dst.nextObject(), EnumeratorEndException);
+}
+
+//////////////////////////////////////////////////////////////////////////
+
+TEST(SkipWhileRange, OneToOne)
+{
+    int src[] = {5};
+    int ans[] = {5};
+
+    auto rng = from(src);
+    auto dst = rng.skipWhile([](int it){return it != 5;});
+
+    CheckRangeEqArray(dst, ans);
+}
+
+TEST(SkipWhileRange_i, OneToOneByIndex)
+{
+    int src[] = {6};
+    int ans[] = {6};
+
+    auto rng = from(src);
+    auto dst = rng.skipWhile_i([](int /*it*/, int idx){return idx > 0;});
+
+    CheckRangeEqArray(dst, ans);
+}
+
+TEST(SkipWhileRange_i, OneToOneByItemValue)
+{
+    int src[] = {6};
+    int ans[] = {6};
+
+    auto rng = from(src);
+    auto dst = rng.skipWhile_i([](int it, int /*idx*/){return it != 6;});
+
+    CheckRangeEqArray(dst, ans);
+}
+
+TEST(SkipWhileRange_i, OneToOneByIndexAndItemValue)
+{
+    int src[] = {6};
+    int ans[] = {6};
+
+    auto rng = from(src);
+    auto dst = rng.skipWhile_i([](int it, int idx){return idx != 0 || it != 6;});
+
+    CheckRangeEqArray(dst, ans);
+}
+
+TEST(SkipWhileRange, OneToZero)
+{
+    int src[] = {5};
+
+    auto rng = from(src);
+    auto dst = rng.skipWhile([](int it){return it == 5;});
+
+    EXPECT_THROW(dst.nextObject(), EnumeratorEndException);
+}
+
+TEST(SkipWhileRange_i, OneToZeroByIndex)
+{
+    int src[] = {6};
+
+    auto rng = from(src);
+    auto dst = rng.skipWhile_i([](int /*it*/, int idx){return idx < 6;});
+
+    EXPECT_THROW(dst.nextObject(), EnumeratorEndException);
+}
+
+TEST(SkipWhileRange_i, OneToZeroByItemValue)
+{
+    int src[] = {6};
+
+    auto rng = from(src);
+    auto dst = rng.skipWhile_i([](int it, int /*idx*/){return it > 0;});
+
+    EXPECT_THROW(dst.nextObject(), EnumeratorEndException);
+}
+
+TEST(SkipWhileRange_i, OneToZeroIndexAndItemValue)
+{
+    int src[] = {6};
+
+    auto rng = from(src);
+    auto dst = rng.skipWhile_i([](int it, int idx){return idx != it;});
+
+    EXPECT_THROW(dst.nextObject(), EnumeratorEndException);
+}
+
+TEST(SkipWhileRange, ZeroToZero)
+{
+    std::vector<int> src;
+
+    auto rng = from(src);
+    auto dst = rng.skipWhile([](int){return false;});
+
+    EXPECT_THROW(rng.nextObject(), EnumeratorEndException);
+}
+
+TEST(SkipWhileRange_i, ZeroToZero)
+{
+    std::vector<int> src;
+
+    auto rng = from(src);
+    auto dst = rng.skipWhile_i([](int /*it*/, int /*idx*/){return true;});
+
+    EXPECT_THROW(rng.nextObject(), EnumeratorEndException);
+}
+
+//////////////////////////////////////////////////////////////////////////

boolinq/boolinq.h

@@ -182,7 +182,7 @@ namespace boolinq
 
         LinqObj<Enumerator<T,std::pair<TE,int> > > takeWhile(std::function<bool(T)> predicate) const
         {
-            return takeWhile_i([=](T a,int){return predicate(a);});
+            return takeWhile_i([=](T t,int){return predicate(t);});
         }
 
         LinqObj<Enumerator<T,std::pair<TE,int> > > skip(int count) const
@@ -190,6 +190,28 @@ namespace boolinq
             return where_i([=](T, int i){return i >= count;});
         }
 
+        LinqObj<Enumerator<T,std::pair<TE,int> > > skipWhile_i(std::function<bool(T,int)> predicate) const
+        {
+            auto enumerator = _enumerator;
+
+            try
+            {
+                int i = 0;
+                while(predicate(TE(enumerator).nextObject(),i++))
+                    enumerator.nextObject();
+            }
+            catch(EnumeratorEndException &){}
+
+            return Enumerator<T,std::pair<TE,int> >([=](std::pair<TE,int> & pair)->T{
+                return pair.first.nextObject();
+            }, std::make_pair(enumerator,0));
+        }
+
+        LinqObj<Enumerator<T,std::pair<TE,int> > > skipWhile(std::function<bool(T)> predicate) const
+        {
+            return skipWhile_i([=](T t, int /*i*/){ return predicate(t);});
+        }
+
         template<typename TRet>
         LinqObj<Enumerator<TRet,std::pair<TE,int> > > select_i(std::function<TRet(T,int)> transform) const
         {

boolinq/boolinq.vcxproj

@@ -95,6 +95,7 @@
     <ClCompile Include="ReverseRangeTest.cpp" />
     <ClCompile Include="SelectRangeTest.cpp" />
     <ClCompile Include="SkipRangeTest.cpp" />
+    <ClCompile Include="SkipWhileRangeTest.cpp" />
     <ClCompile Include="SpeedTest.cpp" />
     <ClCompile Include="SumTest.cpp" />
     <ClCompile Include="TakeRangeTest.cpp" />

boolinq/boolinq.vcxproj.filters

@@ -131,6 +131,9 @@
     <ClCompile Include="TakeWhileRangeTest.cpp">
       <Filter>Test Files\Ranges</Filter>
     </ClCompile>
+    <ClCompile Include="SkipWhileRangeTest.cpp">
+      <Filter>Test Files\Ranges</Filter>
+    </ClCompile>
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="boolinq.h">