init

Author: IS4Code

.gitignore

@@ -0,0 +1,9 @@
+*.sln
+Test/
+Debug/
+Release/
+bin/
+obj/
+Thumbs.db
+*.bat
+*.sh

Accessing/Accessing.cs

@@ -0,0 +1,27 @@
+/* Date: 20.12.2012, Time: 17:02 */
+namespace IllidanS4.SharpUtils.Accessing
+{
+	/// <summary>
+	/// The interface for "get" accessors.
+	/// </summary>
+	public interface IReadAccessor<T>
+	{
+		T Value{get;}
+	}
+	
+	/// <summary>
+	/// The interface for "set" accessors.
+	/// </summary>
+	public interface IWriteAccessor<T>
+	{
+		T Value{set;}
+	}
+	
+	/// <summary>
+	/// The interface for both "get" and "set" accessors.
+	/// </summary>
+	public interface IReadWriteAccessor<T> : IReadAccessor<T>, IWriteAccessor<T>
+	{
+		
+	}
+}

Accessing/AccessorGenerator.cs

@@ -0,0 +1,82 @@
+/* Date: ‎20.12.‎2012, Time: ‏‎17:07 */
+using System;
+using System.Reflection;
+using System.Reflection.Emit;
+
+namespace IllidanS4.SharpUtils.Accessing
+{
+	/// <summary>
+	/// Methods in this class can generate dynamic methods that can return and set a field.
+	/// </summary>
+	public static class AccessorGenerator
+	{
+		/// <summary>
+		/// Generates a method that can set a field's value.
+		/// </summary>
+		/// <param name="fi">The field accessed by the method.</param>
+		/// <param name="target">The object that contains the field, if is it not static.</param>
+		/// <returns>The accessor procedure.</returns>
+		public static Action<T> GenerateSetter<T>(FieldInfo fi, object target)
+		{
+			if(!fi.IsStatic && target == null) throw new ArgumentNullException("target", "Target can be NULL only if field is static.");
+			if(fi.IsStatic && target != null) throw new ArgumentException("Target must be NULL if field is static.", "target");
+			
+			Type t = TypeOf<T>.TypeID;
+			if(!fi.FieldType.IsAssignableFrom(t)) throw new ArgumentException("Field type does not match type argument.", "T");
+			
+			DynamicMethod setter = new DynamicMethod(
+				"set_"+fi.Name,
+				typeof(void),
+				target==null?new[]{t}:new[]{target.GetType(), t},
+				fi.DeclaringType
+			);
+			ILGenerator il = setter.GetILGenerator();
+			if(target!=null)
+			{
+				il.Emit(OpCodes.Ldarg_0);
+				il.Emit(OpCodes.Ldarg_1);
+				if(t != fi.FieldType && t.IsValueType)il.Emit(OpCodes.Box, t);
+				il.Emit(OpCodes.Stfld, fi);
+			}else{
+				il.Emit(OpCodes.Ldarg_0);
+				if(t != fi.FieldType && t.IsValueType)il.Emit(OpCodes.Box, t);
+				il.Emit(OpCodes.Stsfld, fi);
+			}
+			il.Emit(OpCodes.Ret);
+			return (Action<T>)setter.CreateDelegate(TypeOf<Action<T>>.TypeID, target);
+		}
+		
+		/// <summary>
+		/// Generates a method that can get a field's value.
+		/// </summary>
+		/// <param name="fi">The field accessed by the method.</param>
+		/// <param name="target">The object that contains the field, if is it not static.</param>
+		/// <returns>The accessor function.</returns>
+		public static Func<T> GenerateGetter<T>(FieldInfo fi, object target)
+		{
+			if(!fi.IsStatic && target == null) throw new ArgumentNullException("target", "Target can be NULL only if field is static.");
+			if(fi.IsStatic && target != null) throw new ArgumentException("Target must be NULL if field is static.", "target");
+			
+			Type t = TypeOf<T>.TypeID;
+			if(!t.IsAssignableFrom(fi.FieldType)) throw new ArgumentException("Field type does not match type argument.", "T");
+			
+			DynamicMethod getter = new DynamicMethod(
+				"set_"+fi.Name,
+				t,
+				target==null?Type.EmptyTypes:new[]{target.GetType()},
+				fi.DeclaringType
+			);
+			ILGenerator il = getter.GetILGenerator();
+			if(target!=null)
+			{
+				il.Emit(OpCodes.Ldarg_0);
+				il.Emit(OpCodes.Ldfld, fi);
+			}else{
+				il.Emit(OpCodes.Ldsfld, fi);
+			}
+			if(fi.FieldType != t && fi.FieldType.IsValueType)il.Emit(OpCodes.Box, fi.FieldType);
+			il.Emit(OpCodes.Ret);
+			return (Func<T>)getter.CreateDelegate(TypeOf<Func<T>>.TypeID);
+		}
+	}
+}

Accessing/DefinedReadAccessor.cs

@@ -0,0 +1,45 @@
+/* Date: ‎20.12.‎2012, Time: ‏‎17:02 */
+using System;
+namespace IllidanS4.SharpUtils.Accessing
+{
+	/// <summary>
+	/// Read accessor that uses a passed function that returns its value.
+	/// </summary>
+	public class DefinedReadAccessor<T> : IReadAccessor<T>
+	{
+		Func<T> getter;
+		
+		/// <summary>
+		/// Creates a new read accessor using a getter function.
+		/// </summary>
+		/// <param name="getter">The getter function that returns the current value.</param>
+		public DefinedReadAccessor(Func<T> getter)
+		{
+			this.getter = getter;
+		}
+		
+		/// <summary>
+		/// Creates a new read accessor using a tuple storage.
+		/// </summary>
+		/// <param name="tuple">The tuple storage.</param>
+		public DefinedReadAccessor(Tuple<T> tuple) : this(()=>tuple.Item1)
+		{
+			
+		}
+		
+		/// <summary>
+		/// Creates a new read accessor using a constant value.
+		/// </summary>
+		/// <param name="constant">The constant value.</param>
+		public DefinedReadAccessor(T constant) : this(()=>constant)
+		{
+			
+		}
+		
+		public T Value{
+			get{
+				return getter();
+			}
+		}
+	}
+}

Accessing/DefinedReadWriteAccessor.cs

@@ -0,0 +1,28 @@
+/* ‎Date: 20.12.‎2012, Time: ‏‎17:01 */
+using System;
+namespace IllidanS4.SharpUtils.Accessing
+{
+	/// <summary>
+	/// Read-write accessor that uses a getter and setter method.
+	/// </summary>
+	public class DefinedReadWriteAccessor<T> : IReadWriteAccessor<T>
+	{
+		Func<T> getter;
+		Action<T> setter;
+		
+		public DefinedReadWriteAccessor(Func<T> getter, Action<T> setter)
+		{
+			this.getter = getter;
+			this.setter = setter;
+		}
+		
+		public T Value{
+			get{
+				return getter();
+			}
+			set{
+				setter(value);
+			}
+		}
+	}
+}

Accessing/DefinedWriteAccessor.cs

@@ -0,0 +1,20 @@
+/* Date: ‎20.12.‎2012, Time: ‏‎17:01 */
+using System;
+namespace IllidanS4.SharpUtils.Accessing
+{
+	public class DefinedWriteAccessor<T> : IWriteAccessor<T>
+	{
+		Action<T> setter;
+		
+		public DefinedWriteAccessor(Action<T> setter)
+		{
+			this.setter = setter;
+		}
+		
+		public T Value{
+			set{
+				setter(value);
+			}
+		}
+	}
+}

Accessing/FieldAccessor.cs

@@ -0,0 +1,30 @@
+/* Date: ‎20.12.‎2012, Time: ‏‎17:02 */
+using System;
+using System.Reflection;
+
+namespace IllidanS4.SharpUtils.Accessing
+{
+	public sealed class FieldAccessor<T> : IReadWriteAccessor<T>
+	{
+		readonly Action<T> setter;
+		readonly Func<T> getter;
+		
+		public FieldAccessor(FieldInfo field, object target)
+		{
+			if(field.FieldType != TypeOf<T>.TypeID)throw new TypeLoadException("Field is not of type "+TypeOf<T>.TypeID.ToString()+".");
+			if(target != null && field.DeclaringType != target.GetType())throw new TypeLoadException("Target does not contain this field.");
+			setter = AccessorGenerator.GenerateSetter<T>(field, target);
+			getter = AccessorGenerator.GenerateGetter<T>(field, target);
+		}
+		
+		public T Value
+		{
+			get{
+				return getter();
+			}
+			set{
+				setter(value);
+			}
+		}
+	}
+}

Accessing/IIndexable.cs

@@ -0,0 +1,95 @@
+/* Date: 30.11.2014, Time: 11:13 */
+using System;
+using System.Collections.Generic;
+
+namespace IllidanS4.SharpUtils.Accessing
+{
+	/// <summary>
+	/// Represents an object which's index values can be obtained.
+	/// </summary>
+	public interface IIndexableGetter<TKey,TValue>
+	{
+		TValue this[TKey index]{
+			get;
+		}
+	}
+	
+	/// <summary>
+	/// Represents an object which's index values can be set.
+	/// </summary>
+	public interface IIndexableSetter<TKey,TValue>
+	{
+		TValue this[TKey index]{
+			set;
+		}
+	}
+	
+	/// <summary>
+	/// Creates an indexable wrapper around a dictionary.
+	/// </summary>
+	public class IndexDictionaryWrapper<TKey,TValue> : IIndexableGetter<TKey,TValue>, IIndexableSetter<TKey,TValue>
+	{
+		private readonly IDictionary<TKey,TValue> dict;
+		
+		public TValue this[TKey index]
+		{
+			get{
+				return dict[index];
+			}
+			set{
+				dict[index] = value;
+			}
+		}
+		
+		public IndexDictionaryWrapper(IDictionary<TKey,TValue> dict)
+		{
+			this.dict = dict;
+		}
+	}
+	
+	/// <summary>
+	/// Creates an indexable wrapper around a list.
+	/// </summary>
+	public class IndexListWrapper<TElement> : IIndexableGetter<int,TElement>, IIndexableSetter<int,TElement>
+	{
+		private readonly IList<TElement> list;
+		
+		public TElement this[int index]
+		{
+			get{
+				return list[index];
+			}
+			set{
+				list[index] = value;
+			}
+		}
+		
+		public IndexListWrapper(IList<TElement> list)
+		{
+			this.list = list;
+		}
+	}
+	
+	/// <summary>
+	/// Creates an indexable wrapper around a dynamic object.
+	/// </summary>
+	public class DynamicIndexWrapper<TKey,TValue> : IIndexableGetter<TKey,TValue>, IIndexableSetter<TKey,TValue>
+	{
+		private readonly dynamic obj;
+		
+		public DynamicIndexWrapper(dynamic obj)
+		{
+			this.obj = obj;
+		}
+		
+		public TValue this[TKey index]
+		{
+			get{
+				return obj[index];
+			}
+			set{
+				obj[index] = value;
+			}
+		}
+	}
+}

Accessing/OutputAccessor.cs

@@ -0,0 +1,36 @@
+/* Date: ‎20.12.‎2012, Time: ‏‎17:00 */
+using System;
+using IllidanS4.SharpUtils.Unsafe;
+
+namespace IllidanS4.SharpUtils.Accessing
+{
+	public class OutputAccessor<T> : IWriteAccessor<T>
+	{
+		object @ref;
+		
+		public OutputAccessor(out T value)
+		{
+			Extensions.Use(out value);
+			@ref = UnsafeTools.Box(__makeref(value));
+		}
+		
+		public unsafe OutputAccessor(object value)
+		{
+			if(value == null)throw new ArgumentNullException("value");
+			if(!(value is ValueType))throw new ArgumentException("Value can be object only if its type is a value type.", "value");
+			if(!(value is T))throw new ArgumentException("Argument must be of type "+TypeOf<T>.TypeID.ToString()+".", "value");
+			
+			TypedReference tr = __makeref(value);
+			((IntPtr*)(&tr))[1] = value.GetType().TypeHandle.Value;
+			((IntPtr*)(&tr))[0] = (**(IntPtr**)(&tr))+IntPtr.Size;
+			
+			@ref = UnsafeTools.Box(tr);
+		}
+		
+		public T Value{
+			set{
+				__refvalue((TypedReference)@ref, T) = value;
+			}
+		}
+	}
+}