added the skipWhile_i linq function

skipWhile_i function + tests

boolinq/SkipWhileRangeTest.cpp

@@ -24,6 +24,39 @@ TEST(SkipWhileRange, ManyToMore)
     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};
@@ -35,6 +68,40 @@ TEST(SkipWhileRange, ManyToMany)
     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};
@@ -46,6 +113,39 @@ TEST(SkipWhileRange, ManyToLess)
     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};
@@ -57,6 +157,39 @@ TEST(SkipWhileRange, ManyToOne)
     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};
@@ -67,6 +200,36 @@ TEST(SkipWhileRange, ManyToZero)
     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)
@@ -80,6 +243,39 @@ TEST(SkipWhileRange, OneToOne)
     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};
@@ -90,6 +286,36 @@ TEST(SkipWhileRange, OneToZero)
     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;
@@ -100,4 +326,14 @@ TEST(SkipWhileRange, ZeroToZero)
     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,13 +190,15 @@ namespace boolinq
             return where_i([=](T, int i){return i >= count;});
         }
 
-        LinqObj<Enumerator<T,std::pair<TE,int> > > skipWhile(std::function<bool(T)> predicate) const
+        LinqObj<Enumerator<T,std::pair<TE,int> > > skipWhile_i(std::function<bool(T,int)> predicate) const
         {
             auto enumerator = _enumerator;
 
             try
             {
-                while(predicate(TE(enumerator).nextObject()));
+                int i = 0;
+                while(predicate(TE(enumerator).nextObject(),i++))
+                    enumerator.nextObject();
             }
             catch(EnumeratorEndException &){}
 
@@ -205,6 +207,11 @@ namespace boolinq
             }, 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
         {