You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
265 lines
9.9 KiB
265 lines
9.9 KiB
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using System.Text;
|
|
using System.IO;
|
|
|
|
namespace Web.Core {
|
|
|
|
public static class ExtensionMethods {
|
|
|
|
public static Dictionary<TKey, TValue> ToDictionary<TKey, TValue>(this IEnumerable<KeyValuePair<TKey, TValue>> kvps) {
|
|
|
|
Dictionary<TKey, TValue> res = new Dictionary<TKey,TValue>();
|
|
foreach(KeyValuePair<TKey, TValue> kvp in kvps) {
|
|
res[kvp.Key] = kvp.Value;
|
|
}
|
|
return res;
|
|
}
|
|
|
|
public static TDestinationDictionary
|
|
Convert<TSourceDictionary, TDestinationDictionary, TKey, TSource, TDestination>
|
|
(this TSourceDictionary dict, Func<TSource, TDestination> converter)
|
|
where TSourceDictionary : IDictionary<TKey, TSource>
|
|
where TDestinationDictionary : IDictionary<TKey, TDestination>, new()
|
|
{
|
|
|
|
TDestinationDictionary res = new TDestinationDictionary();
|
|
foreach(KeyValuePair<TKey, TSource> kvp in dict) {
|
|
res[kvp.Key] = converter(kvp.Value);
|
|
}
|
|
return res;
|
|
}
|
|
|
|
public delegate TResult RefFunc<T, TResult>(ref T arg);
|
|
|
|
public static RefFunc<T, T> getProperty<T>(this object obj, Func<T> creator) {
|
|
return (ref T arg) => {
|
|
if(arg == null) {
|
|
arg = creator();
|
|
}
|
|
return arg;
|
|
};
|
|
}
|
|
|
|
public static T getProperty<T>(this object obj, ref T arg, Func<T> creator) {
|
|
return obj.getProperty<T>(creator)(ref arg);
|
|
}
|
|
|
|
public static string ToPrintableString(this bool val) {
|
|
return val ? "Enabled" : "Disabled";
|
|
}
|
|
|
|
public static string ToPlainString(this bool val) {
|
|
return val ? "true" : "false";
|
|
}
|
|
|
|
public static string ToPrintableString<T>(this IEnumerable<T> list) {
|
|
return string.Join(",", (from elem in list select elem.ToString()).ToArray());
|
|
}
|
|
|
|
public static string ToDBString(this bool val) {
|
|
return val ? "1" : "0";
|
|
}
|
|
|
|
public static T Safe<T>(this T obj, T defaultValue) {
|
|
if(obj == null) {
|
|
return defaultValue;
|
|
} else {
|
|
return obj;
|
|
}
|
|
}
|
|
|
|
public static HashSet<T> Clone<T>(this HashSet<T> obj) {
|
|
return new HashSet<T>(obj);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Note that actions from todoArr can be executed in any order!
|
|
/// </summary>
|
|
/// <typeparam name="T"></typeparam>
|
|
/// <param name="obj"></param>
|
|
/// <param name="todoArr"></param>
|
|
/// <returns></returns>
|
|
public static T Tee<T>(this T obj, params Action<T>[] todoArr) {
|
|
foreach(Action<T> todo in todoArr) todo(obj);
|
|
return obj;
|
|
}
|
|
|
|
public static T Tee<T>(this T obj, Action todo) {
|
|
todo();
|
|
return obj;
|
|
}
|
|
|
|
private static List<TAttribute> GetAttributeArray<TAttribute>(this System.Reflection.PropertyInfo property) where TAttribute : Attribute {
|
|
return new List<TAttribute>(from attribute in property.GetCustomAttributes(true) where /*Tie(attribute, obj => Console.WriteLine(obj.GetType().FullName))*/ attribute is TAttribute select (TAttribute)attribute);
|
|
}
|
|
|
|
public static TAttribute GetAttribute<TAttribute>(this System.Reflection.PropertyInfo property) where TAttribute : Attribute {
|
|
return property.GetAttributeArray<TAttribute>().Single();
|
|
}
|
|
|
|
public static bool HasAttribute<TAttribute>(this System.Reflection.PropertyInfo property) where TAttribute : Attribute {
|
|
return property.GetAttributeArray<TAttribute>().Count > 0;
|
|
}
|
|
|
|
public static TResult Invoke<TResult>(this System.Reflection.MethodBase method, object obj, params object[] args) {
|
|
return (TResult)method.Invoke(obj, args);
|
|
}
|
|
|
|
public static void Invoke(this System.Reflection.MethodBase method, object obj, params object[] args) {
|
|
method.Invoke(obj, args);
|
|
}
|
|
|
|
public static Dictionary<TKey, TResult> Replace<TKey, TValue, TResult>(this IDictionary<TKey, TValue> dict, Func<TValue, TResult> Replacer) {
|
|
return new List<KeyValuePair<TKey, TResult>>(
|
|
from kvp in dict
|
|
select new KeyValuePair<TKey, TResult>(kvp.Key, Replacer(kvp.Value))
|
|
).ToDictionary();
|
|
}
|
|
|
|
public static Dictionary<TKey, TValue> Replace<TKey, TValue>(this IDictionary<TKey, TValue> dict, Func<TValue, TValue> Replacer) {
|
|
return dict.Replace<TKey, TValue, TValue>(Replacer);
|
|
}
|
|
|
|
public static T Single<T>(this IEnumerable<T> list, Predicate<T> checker, Func<T> onNotFound) {
|
|
try {
|
|
return list.Single(checker.ToFunc());
|
|
} catch(InvalidOperationException) {
|
|
return onNotFound();
|
|
}
|
|
}
|
|
|
|
public static IEnumerable<string> Enquote(this IEnumerable<string> strings) {
|
|
return from str in strings select str.Enquote();
|
|
}
|
|
|
|
public static TResult Check<TSource, TResult>(this TSource obj, Predicate<TSource> checker, Func<TSource, TResult> returnOnFail, TResult returnOnSuccess) {
|
|
if(!checker(obj)) {
|
|
return returnOnFail(obj);
|
|
} else {
|
|
return returnOnSuccess;
|
|
}
|
|
}
|
|
|
|
public static TResult Check<TSource, TResult>(this TSource obj, Predicate<TSource> checker, Func<TSource, Exception> onFail, Func<TSource, TResult> returnOnSuccess) {
|
|
if(!checker(obj)) {
|
|
throw onFail(obj);
|
|
} else {
|
|
return returnOnSuccess(obj);
|
|
}
|
|
}
|
|
|
|
public static void Check<T>(this T obj, Predicate<T> checker, Func<T, Exception> onFail) {
|
|
if(!checker(obj)) {
|
|
throw onFail(obj);
|
|
}
|
|
}
|
|
|
|
public static bool Empty<T>(this IEnumerable<T> list) {
|
|
return list.Count() == 0;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Checks arg given against the predicate given; in case of type mismatch returns false
|
|
/// </summary>
|
|
/// <typeparam name="T"></typeparam>
|
|
/// <param name="arg"></param>
|
|
/// <param name="checker"></param>
|
|
/// <returns></returns>
|
|
public static bool TypedLoosePredicate<T>(this object arg, Predicate<T> checker) {
|
|
return (arg is T) && checker((T)arg);
|
|
}
|
|
|
|
public static Func<object, string> SafeToStringConvertor() {
|
|
return obj => obj == null ? "" : obj.ToString();
|
|
}
|
|
|
|
public static T Recurse<T>(this T obj, Func<T, T> step, Predicate<T> checker) {
|
|
//Debugger.Debug("recurse(" + typeof(T).FullName + ")");
|
|
int i=0;
|
|
while(checker(obj)) {
|
|
//Debugger.Debug("Iteration " + i.ToString());
|
|
obj = step(obj);
|
|
i++;
|
|
}
|
|
//Debugger.Debug("endrecurse(" + typeof(T).Name + ")");
|
|
return obj;
|
|
}
|
|
|
|
public static T[] Slice<T>(this T[] obj, int offset, int length) {
|
|
if(offset<0) throw new IndexOutOfRangeException();
|
|
if(offset+length > obj.Length) throw new IndexOutOfRangeException();
|
|
T[] res = new T[length];
|
|
Array.Copy(obj, offset, res, 0, length);
|
|
return res;
|
|
}
|
|
|
|
public static T[] Slice<T>(this T[] arr, int offset) {
|
|
return arr.Slice(offset, arr.Length-offset);
|
|
}
|
|
|
|
public static T TryValues<T>(this T obj, params Func<T>[] trials) {
|
|
//Debugger.Debug("TryValues(" + typeof(T).FullName + ")");
|
|
return new KeyValuePair<T, Func<T>[]>(obj, trials).Recurse(
|
|
kvp => new KeyValuePair<T, Func<T>[]>(kvp.Value[0](), kvp.Value.Slice(1)),
|
|
kvp => !kvp.Value.Empty() && kvp.Key == null
|
|
).Key;
|
|
}
|
|
|
|
public static IEnumerable<T> Replace<T>(this IEnumerable<T> list, Func<T, T> replacer) {
|
|
return from elem in list select replacer(elem);
|
|
}
|
|
|
|
internal static string ToStringOnFail(this bool test, Lazy<string> onFail) {
|
|
return test ? "" : onFail();
|
|
}
|
|
|
|
public static string Join(this IEnumerable<string> strings, string separator) {
|
|
return String.Join(separator, strings.ToArray());
|
|
}
|
|
|
|
public static IEnumerable<T> GetSorted<T>(this IEnumerable<T> list) {
|
|
return from elem in list orderby elem select elem;
|
|
}
|
|
|
|
public static Int64 ToInt64(this decimal number) {
|
|
return decimal.ToInt64(number);
|
|
}
|
|
|
|
public static string ToUTCString(this DateTime date) {
|
|
return date.ToUniversalTime().ToString("u");
|
|
}
|
|
|
|
public static IEnumerable<T> ToSequence<T>(this T obj, Func<T, IEnumerable<T>> nextElementsGenerator) where T : class {
|
|
yield return obj;
|
|
foreach(var sub in nextElementsGenerator(obj)) {
|
|
foreach(var subsub in sub.ToSequence(nextElementsGenerator)) {
|
|
yield return subsub;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static T Last<T>(this List<T> list) {
|
|
return list[list.Count-1];
|
|
}
|
|
|
|
public static IEnumerable<T> Union<T>(this IEnumerable<T> enumerable, params T[] second) {
|
|
return enumerable.Union((IEnumerable<T>)second);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Code taken from http://msdn.microsoft.com/en-us/library/system.io.stream.write.aspx
|
|
/// </summary>
|
|
/// <param name="input"></param>
|
|
/// <param name="output"></param>
|
|
public static void WriteTo(this Stream input, Stream output) {
|
|
const int size = 4096;
|
|
byte[] bytes = new byte[4096];
|
|
int numBytes;
|
|
while((numBytes = input.Read(bytes, 0, size)) > 0)
|
|
output.Write(bytes, 0, numBytes);
|
|
}
|
|
|
|
}
|
|
}
|
|
|