wasSharp – Diff between revs 47 and 49

Subversion Repositories:

?pathlinks?

Rev 47 – Go to most recent revision – Details – Blame – Last modification – View Log

Only display areas with differences – Ignore whitespace

 ï»¿///////////////////////////////////////////////////////////////////////////
 //  Copyright (C) Wizardry and Steamworks 2013 - License: GNU GPLv3      //
 //  Please see: http://www.gnu.org/licenses/gpl.html for legal details,  //
 //  rights of fair usage, the disclaimer and warranty conditions.        //
 ///////////////////////////////////////////////////////////////////////////
 using System;
 using System.Collections.Generic;
 using System.Linq;
 namespace wasSharp.Linq
+{
     public static class Extensions
+    {
         ///////////////////////////////////////////////////////////////////////////
         //    Copyright (C) 2017 Wizardry and Steamworks - License: GNU GPLv3    //
         ///////////////////////////////////////////////////////////////////////////
         /// <summary>
         ///     A functional implementation of a switch clause.
         /// </summary>
         /// <typeparam name="T">the type of items in the query</typeparam>
         /// <param name="query">the selector query</param>
         /// <param name="default">the function to execute when no case matches</param>
         /// <param name="case">a list of predicates representing the switch cases,
         /// where each predicate has to return True or False indicating whether
         /// fallthrough should occur.
         /// </param>
         /// <remarks>when used, the default action must be explicitly specified
         /// due to language restrictions
         /// </remarks>
         public static void Switch<T>(this IEnumerable<T> query,
             // default
             Action<T> @default,
             // case
             // case
             // ...
             params Predicate<T>[] @case)
+        {
             if (@case.Length % 2 != 0)
                 throw new ArgumentException("Pairs of predicates expected.");
             var enumerable = query as IList<T> ?? query.ToList();
             using (var iter = enumerable.GetEnumerator())
+            {
                 while (iter.MoveNext())
+                {
                     var match = false;
                     for (var i = 0; i < @case.Length; i += 2)
+                    {
                         if (!@case[i].Invoke(iter.Current))
                             continue;
                         if (@case[i + 1].Invoke(iter.Current))
                             return;
                         match = true;
+                    }
                     if (!match)
                         @default.Invoke(iter.Current);
+                }
+            }
+        }
         ///////////////////////////////////////////////////////////////////////////
         //    Copyright (C) 2017 Wizardry and Steamworks - License: GNU GPLv3    //
         ///////////////////////////////////////////////////////////////////////////
         /// <summary>
+        ///     A functional implementation of a switch clause.
+        /// </summary>
+        /// <typeparam name="T">the type of the item to query</typeparam>
+        /// <param name="query">the selector query</param>
+        /// <param name="default">the function to execute when no case matches</param>
+        /// <param name="case">a list of predicates representing the switch cases,
+        /// where each predicate has to return True or False indicating whether
+        /// fallthrough should occur.
+        /// </param>
+        /// <remarks>when used, the default action must be explicitly specified
+        /// due to language restrictions
+        /// </remarks>
+        public static void Switch<T>(this T query,
+            // default
+            Action<T> @default,
+            // case
+            // case
+            // ...
+            params Predicate<T>[] @case)
+        {
+            if (@case.Length % 2 != 0)
+                throw new ArgumentException("Pairs of predicates expected.");
+            var match = false;
+            for (var i = 0; i < @case.Length; i += 2)
+            {
+                if (!@case[i].Invoke(query))
+                    continue;
+                if (@case[i + 1].Invoke(query))
+                    return;
+                match = true;
+            }
+            if (!match)
+                @default.Invoke(query);
+        }
+        ///////////////////////////////////////////////////////////////////////////
+        //    Copyright (C) 2017 Wizardry and Steamworks - License: GNU GPLv3    //
+        ///////////////////////////////////////////////////////////////////////////
+        /// <summary>
         ///     Invokes pf in case the predicate p resolves or qf in case the predicate q resolves, or ef otherwise.
         /// </summary>
         /// <typeparam name="T">the type of items in the query</typeparam>
         /// <param name="query">the selector query</param>
         /// <param name="p">the condition for invoking pf</param>
         /// <param name="pf">the action to invoke in case p resolves</param>
         /// <param name="q">the condition for invoking qf</param>
         /// <param name="qf">the action to invoke in case q resolves</param>
         /// <param name="ef">the action to invoke otherwise</param>
         public static void ForAll<T>(this ParallelQuery<T> query, Predicate<T> p, Action<T> pf, Predicate<T> q, Action<T> qf, Action<T> ef)
+        {
             query.ForAll(o =>
+            {
                 if (p.Invoke(o))
+                {
                     pf.Invoke(o);
+                }
                 else if (q.Invoke(o))
+                {
                     qf.Invoke(o);
+                }
                 else
+                {
                     ef.Invoke(o);
+                }
             });
+        }
         ///////////////////////////////////////////////////////////////////////////
         //    Copyright (C) 2017 Wizardry and Steamworks - License: GNU GPLv3    //
         ///////////////////////////////////////////////////////////////////////////
         /// <summary>
         ///     Invokes pf in case the predicate p resolves or qf in case the predicate q resolves.
         /// </summary>
         /// <typeparam name="T">the type of items in the query</typeparam>
         /// <param name="query">the selector query</param>
         /// <param name="p">the condition for invoking pf</param>
         /// <param name="pf">the action to invoke in case p resolves</param>
         /// <param name="q">the condition for invoking qf</param>
         /// <param name="qf">the action to invoke in case q resolves</param>
         public static void ForAll<T>(this ParallelQuery<T> query, Predicate<T> p, Action<T> pf, Predicate<T> q, Action<T> qf)
+        {
             query.ForAll(o =>
+            {
                 if (p.Invoke(o))
+                {
                     pf.Invoke(o);
                     return;
+                }
                 if (q.Invoke(o))
+                {
                     qf.Invoke(o);
                     return;
+                }
             });
+        }
         ///////////////////////////////////////////////////////////////////////////
         //    Copyright (C) 2017 Wizardry and Steamworks - License: GNU GPLv3    //
         ///////////////////////////////////////////////////////////////////////////
         /// <summary>
         ///     Invokes pass if and only if predicate resovles or fail otherwise.
         /// </summary>
         /// <typeparam name="T">the type of items in the query</typeparam>
         /// <param name="query">the selector query</param>
         /// <param name="condition">the condition for invoking pf</param>
         /// <param name="pass">the function to invoke in case the predicate resolves</param>
         /// <param name="fail">the function to invoke otherwise</param>
         public static void ForAll<T>(this ParallelQuery<T> query, Predicate<T> condition, Action<T> pass, Action<T> fail)
+        {
             query.ForAll(o =>
+            {
                 switch (condition.Invoke(o))
+                {
                     case true:
                         pass.Invoke(o);
                         return;
                     default:
                         fail.Invoke(o);
                         return;
+                }
             });
+        }
         ///////////////////////////////////////////////////////////////////////////
         //    Copyright (C) 2017 Wizardry and Steamworks - License: GNU GPLv3    //
         ///////////////////////////////////////////////////////////////////////////
         /// <summary>
         ///     Invokes pass if and only if condition holds or fail otherwise.
         /// </summary>
         /// <typeparam name="T">the return type of the pass and fail functions</typeparam>
         /// <param name="condition">the branch condition</param>
         /// <param name="pass">function with no parameters and return type T in case condition passes</param>
         /// <param name="fail">function with no parameters and return type T in case condition fails</param>
         /// <returns>the result of pass in case condition holds or the result of fail otherwise</returns>
         public static T IfElse<T>(this bool condition, Func<T> pass, Func<T> fail)
+        {
             return condition ? pass.Invoke() : fail.Invoke();
+        }
         ///////////////////////////////////////////////////////////////////////////
         //    Copyright (C) 2017 Wizardry and Steamworks - License: GNU GPLv3    //
         ///////////////////////////////////////////////////////////////////////////
         /// <summary>
         ///     Invokes pass if and only if condition holds or fail otherwise.
         /// </summary>
         /// <typeparam name="U">the type of the argument to pass and fail</typeparam>
         /// <typeparam name="V">the return type of pass and fail</typeparam>
         /// <param name="condition">the branch condition</param>
         /// <param name="pass">function that takes argument arg and returns type V in case condition holds</param>
         /// <param name="fail">function that takes argument arg and returns type V in case condition fails</param>
         /// <param name="arg">the argument passed to pass or fail functions</param>
         /// <returns>the result of pass in case condition holds or the result of fail otherwise</returns>
         public static V IfElse<U, V>(this bool condition, Func<U, V> pass, Func<U, V> fail, U arg = default(U))
+        {
             return condition ? pass.Invoke(arg) : fail.Invoke(arg);
+        }
         ///////////////////////////////////////////////////////////////////////////
         //    Copyright (C) 2017 Wizardry and Steamworks - License: GNU GPLv3    //
         ///////////////////////////////////////////////////////////////////////////
         /// <summary>
         ///     Invokes pass if and only if condition holds or fail otherwise.
         /// </summary>
         /// <typeparam name="T">the type of the argument to pass and fail</typeparam>
         /// <param name="condition">the branch condition</param>
         /// <param name="pass">function that takes argument arg and returns nothing in case condition holds</param>
         /// <param name="fail">function that takes argument arg and returns nothing in case condition fails</param>
         /// <param name="arg">the optional argument passed to pass or fail functions</param>
         public static void IfElse<T>(this bool condition, Action<T> pass, Action<T> fail, T arg = default(T))
+        {
             switch (condition)
+            {
                 case true:
                     pass.Invoke(arg);
                     return;
                 default:
                     fail.Invoke(arg);
                     return;
+            }
+        }
         ///////////////////////////////////////////////////////////////////////////
         //    Copyright (C) 2017 Wizardry and Steamworks - License: GNU GPLv3    //
         ///////////////////////////////////////////////////////////////////////////
         /// <summary>
         ///     Invokes pass if and only if condition holds or fail otherwise.
         /// </summary>
         /// <typeparam name="U">the type of the first argument to the pass or fail functions</typeparam>
         /// <typeparam name="V">the type of the second argument to the pass or fail functions</typeparam>
         /// <param name="condition">the branch condition</param>
         /// <param name="pass">function that takes argument arg and returns nothing in case condition holds</param>
         /// <param name="fail">function that takes argument arg and returns nothing in case condition fails</param>
         /// <param name="arga">first optional argument passed to pass or fail functions</param>
         /// <param name="argb">second optional argument passed to pass or fail functions</param>
         public static void IfElse<U, V>(this bool condition, Action<U, V> pass, Action<U, V> fail, U arga = default(U), V argb = default(V))
+        {
             switch (condition)
+            {
                 case true:
                     pass.Invoke(arga, argb);
                     return;
                 default:
                     fail.Invoke(arga, argb);
                     return;
+            }
+        }
         ///////////////////////////////////////////////////////////////////////////
         //    Copyright (C) 2016 Wizardry and Steamworks - License: GNU GPLv3    //
         ///////////////////////////////////////////////////////////////////////////
         /// <summary>
         ///     Returns true of an enumerable contains more than one element.
         /// </summary>
         /// <typeparam name="T">the type of the enumeration</typeparam>
         /// <param name="e">the enumeration</param>
         /// <returns>true if enumeration contains more than one element</returns>
         /// <remarks>O(2) worst case</remarks>
         public static bool Some<T>(this IEnumerable<T> e)
+        {
             var i = 0;
             using (var iter = e.GetEnumerator())
+            {
                 while (iter.MoveNext())
+                {
                     if (++i > 1)
                         return true;
+                }
                 return false;
+            }
+        }
         /// <summary>
         ///     Sequentially removes all the elements from the first sequence that are in the second sequence
         ///     or all the elements from the second sequence that are in the first sequence.
         /// </summary>
         /// <typeparam name="T">the type o the collection</typeparam>
         /// <param name="o">the first sequence to remove from</param>
         /// <param name="p">the second sequence to remove</param>
         /// <returns>the first sequence excluding the second sequence or the second sequence excluding the first sequence</returns>
         public static IEnumerable<T> SequenceExceptAny<T>(this IEnumerable<T> o, IEnumerable<T> p) where T : IEquatable<T>
+        {
             var l = new List<T>(o);
             var r = new List<T>(p);
             return l.Count > r.Count
                 ? l.Zip(r, (x, y) => x.Equals(y) ? default(T) : y)
                     .Concat(l.Skip(r.Count))
                     .Where(q => q != null && !q.Equals(default(T)))
                 : r.Zip(l, (x, y) => x.Equals(y) ? default(T) : y)
                     .Concat(r.Skip(l.Count))
                     .Where(q => q != null && !q.Equals(default(T)));
+        }
         /// <summary>
         ///     Sequentially removes all the elements from the first sequence that are in the second sequence.
         /// </summary>
         /// <typeparam name="T">the type o the collection</typeparam>
         /// <param name="o">the first sequence to remove from</param>
         /// <param name="p">the second sequence to remove</param>
         /// <returns>the first sequence excluding the second sequence</returns>
         public static IEnumerable<T> SequenceExcept<T>(this IEnumerable<T> a, IEnumerable<T> b) where T : IEquatable<T>
+        {
             using (var ea = a.GetEnumerator())
+            {
                 using (var eb = b.GetEnumerator())
+                {
                     while (ea.MoveNext())
+                    {
                         if (eb.MoveNext() && ea.Current.Equals(eb.Current))
                             continue;
                         yield return ea.Current;
+                    }
+                }
+            }
+        }
+    }
+}