Changeset 32 in wasSharp


Ignore:
Timestamp:
Apr 20, 2017, 11:33:02 PM (6 months ago)
Author:
office
Message:
  • Added lambda branching.
  • Added URL comparing routine.
Files:
3 edited

Legend:

Unmodified
Added
Removed
  • Linq.cs

    r29 r32  
    1313    public static class Extensions
    1414    {
     15        ///////////////////////////////////////////////////////////////////////////
     16        //    Copyright (C) 2017 Wizardry and Steamworks - License: GNU GPLv3    //
     17        ///////////////////////////////////////////////////////////////////////////
     18        /// <summary>
     19        ///     A functional implementation of a switch clause.
     20        /// </summary>
     21        /// <typeparam name="T">the type of items in the query</typeparam>
     22        /// <param name="query">the selector query</param>
     23        /// <param name="default">the function to execute when no case matches</param>
     24        /// <param name="case">a list of predicates representing the switch cases,
     25        /// where each predicate has to return True or False indicating whether
     26        /// fallthrough should occur.
     27        /// </param>
     28        public static void Switch<T>(this IEnumerable<T> query,
     29            // default
     30            Action<T> @default,
     31            // case
     32            // case
     33            // ...
     34            params Predicate<T>[] @case)
     35        {
     36            if (@case.Length % 2 != 0)
     37                throw new ArgumentException("Pairs of predicates expected.");
     38
     39            try
     40            {
     41                using (var iter = query.GetEnumerator())
     42                {
     43                    while (iter.MoveNext())
     44                    {
     45                        for (var i = 0; i < @case.Length; i += 2)
     46                        {
     47                            if (@case[i].Invoke(iter.Current) && @case[i + 1].Invoke(iter.Current))
     48                                throw new Exception();
     49                        }
     50                    }
     51                }
     52                @default.Invoke(query.Last());
     53            }
     54            catch
     55            {
     56            }
     57        }
     58
     59        ///////////////////////////////////////////////////////////////////////////
     60        //    Copyright (C) 2017 Wizardry and Steamworks - License: GNU GPLv3    //
     61        ///////////////////////////////////////////////////////////////////////////
     62        /// <summary>
     63        ///     Invokes pf in case the predicate p resolves or qf in case the predicate q resolves, or ef otherwise.
     64        /// </summary>
     65        /// <typeparam name="T">the type of items in the query</typeparam>
     66        /// <param name="query">the selector query</param>
     67        /// <param name="p">the condition for invoking pf</param>
     68        /// <param name="pf">the action to invoke in case p resolves</param>
     69        /// <param name="q">the condition for invoking qf</param>
     70        /// <param name="qf">the action to invoke in case q resolves</param>
     71        /// <param name="ef">the action to invoke otherwise</param>
     72        public static void ForAll<T>(this ParallelQuery<T> query, Predicate<T> p, Action<T> pf, Predicate<T> q, Action<T> qf, Action<T> ef)
     73        {
     74            query.ForAll(o =>
     75            {
     76                if (p.Invoke(o))
     77                {
     78                    pf.Invoke(o);
     79                }
     80                else if (q.Invoke(o))
     81                {
     82                    qf.Invoke(o);
     83                }
     84                else
     85                {
     86                    ef.Invoke(o);
     87                }
     88            });
     89        }
     90
     91        ///////////////////////////////////////////////////////////////////////////
     92        //    Copyright (C) 2017 Wizardry and Steamworks - License: GNU GPLv3    //
     93        ///////////////////////////////////////////////////////////////////////////
     94        /// <summary>
     95        ///     Invokes pf in case the predicate p resolves or qf in case the predicate q resolves.
     96        /// </summary>
     97        /// <typeparam name="T">the type of items in the query</typeparam>
     98        /// <param name="query">the selector query</param>
     99        /// <param name="p">the condition for invoking pf</param>
     100        /// <param name="pf">the action to invoke in case p resolves</param>
     101        /// <param name="q">the condition for invoking qf</param>
     102        /// <param name="qf">the action to invoke in case q resolves</param>
     103        public static void ForAll<T>(this ParallelQuery<T> query, Predicate<T> p, Action<T> pf, Predicate<T> q, Action<T> qf)
     104        {
     105            query.ForAll(o =>
     106            {
     107                if (p.Invoke(o))
     108                {
     109                    pf.Invoke(o);
     110                    return;
     111                }
     112
     113                if (q.Invoke(o))
     114                {
     115                    qf.Invoke(o);
     116                    return;
     117                }
     118            });
     119        }
     120
     121        ///////////////////////////////////////////////////////////////////////////
     122        //    Copyright (C) 2017 Wizardry and Steamworks - License: GNU GPLv3    //
     123        ///////////////////////////////////////////////////////////////////////////
     124        /// <summary>
     125        ///     Invokes pass if and only if predicate resovles or fail otherwise.
     126        /// </summary>
     127        /// <typeparam name="T">the type of items in the query</typeparam>
     128        /// <param name="query">the selector query</param>
     129        /// <param name="condition">the condition for invoking pf</param>
     130        /// <param name="pass">the function to invoke in case the predicate resolves</param>
     131        /// <param name="fail">the function to invoke otherwise</param>
     132        public static void ForAll<T>(this ParallelQuery<T> query, Predicate<T> condition, Action<T> pass, Action<T> fail)
     133        {
     134            query.ForAll(o =>
     135            {
     136                switch (condition.Invoke(o))
     137                {
     138                    case true:
     139                        pass.Invoke(o);
     140                        return;
     141
     142                    default:
     143                        fail.Invoke(o);
     144                        return;
     145                }
     146            });
     147        }
     148
     149        ///////////////////////////////////////////////////////////////////////////
     150        //    Copyright (C) 2017 Wizardry and Steamworks - License: GNU GPLv3    //
     151        ///////////////////////////////////////////////////////////////////////////
     152        /// <summary>
     153        ///     Invokes pass if and only if condition holds or fail otherwise.
     154        /// </summary>
     155        /// <typeparam name="T">the return type of the pass and fail functions</typeparam>
     156        /// <param name="condition">the branch condition</param>
     157        /// <param name="pass">function with no parameters and return type T in case condition passes</param>
     158        /// <param name="fail">function with no parameters and return type T in case condition fails</param>
     159        /// <returns>the result of pass in case condition holds or the result of fail otherwise</returns>
     160        public static T IfElse<T>(this bool condition, Func<T> pass, Func<T> fail)
     161        {
     162            return condition ? pass.Invoke() : fail.Invoke();
     163        }
     164
     165        ///////////////////////////////////////////////////////////////////////////
     166        //    Copyright (C) 2017 Wizardry and Steamworks - License: GNU GPLv3    //
     167        ///////////////////////////////////////////////////////////////////////////
     168        /// <summary>
     169        ///     Invokes pass if and only if condition holds or fail otherwise.
     170        /// </summary>
     171        /// <typeparam name="U">the type of the argument to pass and fail</typeparam>
     172        /// <typeparam name="V">the return type of pass and fail</typeparam>
     173        /// <param name="condition">the branch condition</param>
     174        /// <param name="pass">function that takes argument arg and returns type V in case condition holds</param>
     175        /// <param name="fail">function that takes argument arg and returns type V in case condition fails</param>
     176        /// <param name="arg">the argument passed to pass or fail functions</param>
     177        /// <returns>the result of pass in case condition holds or the result of fail otherwise</returns>
     178        public static V IfElse<U, V>(this bool condition, Func<U, V> pass, Func<U, V> fail, U arg = default(U))
     179        {
     180            return condition ? pass.Invoke(arg) : fail.Invoke(arg);
     181        }
     182
     183        ///////////////////////////////////////////////////////////////////////////
     184        //    Copyright (C) 2017 Wizardry and Steamworks - License: GNU GPLv3    //
     185        ///////////////////////////////////////////////////////////////////////////
     186        /// <summary>
     187        ///     Invokes pass if and only if condition holds or fail otherwise.
     188        /// </summary>
     189        /// <typeparam name="T">the type of the argument to pass and fail</typeparam>
     190        /// <param name="condition">the branch condition</param>
     191        /// <param name="pass">function that takes argument arg and returns nothing in case condition holds</param>
     192        /// <param name="fail">function that takes argument arg and returns nothing in case condition fails</param>
     193        /// <param name="arg">the optional argument passed to pass or fail functions</param>
     194        public static void IfElse<T>(this bool condition, Action<T> pass, Action<T> fail, T arg = default(T))
     195        {
     196            switch (condition)
     197            {
     198                case true:
     199                    pass.Invoke(arg);
     200                    return;
     201
     202                default:
     203                    fail.Invoke(arg);
     204                    return;
     205            }
     206        }
     207
     208        ///////////////////////////////////////////////////////////////////////////
     209        //    Copyright (C) 2017 Wizardry and Steamworks - License: GNU GPLv3    //
     210        ///////////////////////////////////////////////////////////////////////////
     211        /// <summary>
     212        ///     Invokes pass if and only if condition holds or fail otherwise.
     213        /// </summary>
     214        /// <typeparam name="U">the type of the first argument to the pass or fail functions</typeparam>
     215        /// <typeparam name="V">the type of the second argument to the pass or fail functions</typeparam>
     216        /// <param name="condition">the branch condition</param>
     217        /// <param name="pass">function that takes argument arg and returns nothing in case condition holds</param>
     218        /// <param name="fail">function that takes argument arg and returns nothing in case condition fails</param>
     219        /// <param name="arga">first optional argument passed to pass or fail functions</param>
     220        /// <param name="argb">second optional argument passed to pass or fail functions</param>
     221        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))
     222        {
     223            switch (condition)
     224            {
     225                case true:
     226                    pass.Invoke(arga, argb);
     227                    return;
     228
     229                default:
     230                    fail.Invoke(arga, argb);
     231                    return;
     232            }
     233        }
     234
    15235        ///////////////////////////////////////////////////////////////////////////
    16236        //    Copyright (C) 2016 Wizardry and Steamworks - License: GNU GPLv3    //
  • Properties/AssemblyInfo.cs

    r30 r32  
    2727// [assembly: AssemblyVersion("1.0.*")]
    2828
    29 [assembly: AssemblyVersion("1.44.*")]
     29[assembly: AssemblyVersion("1.45.*")]
  • Web/Utilities/WebExtensions.cs

    r27 r32  
    7979        //  Copyright (C) Wizardry and Steamworks 2015 - License: GNU GPLv3      //
    8080        ///////////////////////////////////////////////////////////////////////////
     81        /// <summary>Retrieves the port from an HttpListener prefix</summary>
    8182        /// <param name="prefix">a HttpListener prefix</param>
    8283        /// <returns>the port of the HttpListener</returns>
     
    9192            return split.Length <= 1 || !long.TryParse(split[1], out port) ? 80 : port;
    9293        }
     94
     95        ///////////////////////////////////////////////////////////////////////////
     96        //  Copyright (C) Wizardry and Steamworks 2017 - License: GNU GPLv3      //
     97        ///////////////////////////////////////////////////////////////////////////
     98        /// <summary>
     99        ///     Compare Two URIs
     100        /// </summary>
     101        /// <param name="l">the URI to compare</param>
     102        /// <param name="r">the URI to compare to</param>
     103        /// <param name="components">optionally the components to compare</param>
     104        /// <returns>true if the URIs match</returns>
     105        public static bool UriIsEqualTo(this string l, string r,
     106            UriComponents components = UriComponents.Host | UriComponents.PathAndQuery)
     107        {
     108            try
     109            {
     110                Uri a = new Uri(l);
     111                Uri b = new Uri(r);
     112
     113                return Uri.Compare(a, b, components,
     114                    UriFormat.SafeUnescaped, StringComparison.OrdinalIgnoreCase) == 0;
     115            }
     116            catch
     117            {
     118                return false;
     119            }
     120        }
    93121    }
    94122}
Note: See TracChangeset for help on using the changeset viewer.