wasSharp – Blame information for rev 21

Subversion Repositories:
Rev:
Rev Author Line No. Line
2 zed 1 ///////////////////////////////////////////////////////////////////////////
2 // Copyright (C) Wizardry and Steamworks 2013 - License: GNU GPLv3 //
3 // Please see: http://www.gnu.org/licenses/gpl.html for legal details, //
4 // rights of fair usage, the disclaimer and warranty conditions. //
5 ///////////////////////////////////////////////////////////////////////////
6  
7 using System;
8 using System.Collections.Generic;
9 using System.Linq;
10 using System.Reflection;
11  
12 namespace wasSharp
13 {
7 office 14 public static class Reflection
2 zed 15 {
16 ///////////////////////////////////////////////////////////////////////////
17 // Copyright (C) 2014 Wizardry and Steamworks - License: GNU GPLv3 //
18 ///////////////////////////////////////////////////////////////////////////
19 /// <summary>
20 /// Retrieves an attribute of type T from an enumeration.
21 /// </summary>
22 /// <returns>an attribute of type T</returns>
5 eva 23 public static T GetAttributeFromEnumValue<T>(Enum value) where T : Attribute
2 zed 24 {
3 eva 25 return (T) value.GetType()
2 zed 26 .GetRuntimeField(value.ToString())
10 office 27 .GetCustomAttributes(typeof(T), false)
2 zed 28 .SingleOrDefault();
29 }
30  
31 ///////////////////////////////////////////////////////////////////////////
32 // Copyright (C) 2015 Wizardry and Steamworks - License: GNU GPLv3 //
33 ///////////////////////////////////////////////////////////////////////////
34 /// <summary>
35 /// Returns all the attributes of type T of an enumeration.
36 /// </summary>
37 /// <typeparam name="T">the attribute to retrieve</typeparam>
38 /// <returns>a list of attributes</returns>
5 eva 39 public static IEnumerable<T> GetEnumAttributes<T>(Enum e) where T : Attribute
2 zed 40 {
7 office 41 return e.GetType().GetRuntimeFields().ToArray()
3 eva 42 .AsParallel()
5 eva 43 .Select(o => GetAttributeFromEnumValue<T>((Enum) o.GetValue(Activator.CreateInstance<T>())));
2 zed 44 }
45  
46 ///////////////////////////////////////////////////////////////////////////
47 // Copyright (C) 2014 Wizardry and Steamworks - License: GNU GPLv3 //
48 ///////////////////////////////////////////////////////////////////////////
49 /// <summary>
50 /// Returns all the field names of an enumeration.
51 /// </summary>
52 /// <returns>the field names</returns>
5 eva 53 public static IEnumerable<string> GetEnumNames<T>()
2 zed 54 {
55 return
10 office 56 typeof(T).GetRuntimeFields().ToArray()
2 zed 57 .AsParallel()
10 office 58 .Select(o => o.GetCustomAttribute(typeof(NameAttribute), false))
2 zed 59 .Select(o => (o as NameAttribute)?.Name)
60 .Where(o => !string.IsNullOrEmpty(o))
61 .Select(o => o);
62 }
63  
64 ///////////////////////////////////////////////////////////////////////////
65 // Copyright (C) 2014 Wizardry and Steamworks - License: GNU GPLv3 //
66 ///////////////////////////////////////////////////////////////////////////
67 /// <summary>
68 /// Returns all the values of an enumeration.
69 /// </summary>
70 /// <returns>the values of the enumeration</returns>
5 eva 71 public static IEnumerable<T> GetEnumValues<T>()
2 zed 72 {
10 office 73 return Enum.GetValues(typeof(T)).Cast<object>().Select(value => (T) value);
2 zed 74 }
75  
76 ///////////////////////////////////////////////////////////////////////////
77 // Copyright (C) 2015 Wizardry and Steamworks - License: GNU GPLv3 //
78 ///////////////////////////////////////////////////////////////////////////
79 /// <summary>
7 office 80 /// Get the name from an enumeration value.
2 zed 81 /// </summary>
82 /// <param name="value">an enumeration value</param>
83 /// <returns>the description or the empty string</returns>
5 eva 84 public static string GetNameFromEnumValue(Enum value)
2 zed 85 {
7 office 86 var attribute = value.GetType()
2 zed 87 .GetRuntimeField(value.ToString())
10 office 88 .GetCustomAttributes(typeof(NameAttribute), false)
2 zed 89 .SingleOrDefault() as NameAttribute;
90 return attribute?.Name;
91 }
92  
93 ///////////////////////////////////////////////////////////////////////////
94 // Copyright (C) 2015 Wizardry and Steamworks - License: GNU GPLv3 //
95 ///////////////////////////////////////////////////////////////////////////
96 /// <summary>
97 /// Get the description from an enumeration value.
98 /// </summary>
99 /// <param name="value">an enumeration value</param>
100 /// <returns>the description or the empty string</returns>
5 eva 101 public static string GetDescriptionFromEnumValue(Enum value)
2 zed 102 {
7 office 103 var attribute = value.GetType()
2 zed 104 .GetRuntimeField(value.ToString())
10 office 105 .GetCustomAttributes(typeof(DescriptionAttribute), false)
2 zed 106 .SingleOrDefault() as DescriptionAttribute;
107 return attribute?.Description;
108 }
109  
110 ///////////////////////////////////////////////////////////////////////////
111 // Copyright (C) 2015 Wizardry and Steamworks - License: GNU GPLv3 //
112 ///////////////////////////////////////////////////////////////////////////
113 /// <summary>
114 /// Get enumeration value from its name attribute.
115 /// </summary>
116 /// <typeparam name="T">the enumeration type</typeparam>
117 /// <param name="name">the description of a member</param>
21 office 118 /// <param name="comparison">the string comparison to use</param>
2 zed 119 /// <returns>the value or the default of T if case no name attribute found</returns>
21 office 120 public static T GetEnumValueFromName<T>(string name, StringComparison comparison = StringComparison.OrdinalIgnoreCase)
2 zed 121 {
10 office 122 var field = typeof(T).GetRuntimeFields().ToArray()
2 zed 123 .AsParallel().SelectMany(f => f.GetCustomAttributes(
10 office 124 typeof(NameAttribute), false), (
125 f, a) => new {Field = f, Att = a})
126 .SingleOrDefault(a => Strings.StringEquals(((NameAttribute) a.Att)
21 office 127 .Name, name, comparison));
3 eva 128 return field != null ? (T) field.Field.GetValue(Activator.CreateInstance<T>()) : default(T);
2 zed 129 }
130  
131 ///////////////////////////////////////////////////////////////////////////
132 // Copyright (C) 2015 Wizardry and Steamworks - License: GNU GPLv3 //
133 ///////////////////////////////////////////////////////////////////////////
134 /// <summary>
7 office 135 /// Get the name of a structure member.
2 zed 136 /// </summary>
137 /// <typeparam name="T">the type of the structure to search</typeparam>
138 /// <param name="structure">the structure to search</param>
139 /// <param name="item">the value of the item to search</param>
140 /// <returns>the description or the empty string</returns>
5 eva 141 public static string GetStructureMemberName<T>(T structure, object item) where T : struct
2 zed 142 {
10 office 143 var field = typeof(T).GetRuntimeFields().ToArray()
144 .AsParallel().SelectMany(f => f.GetCustomAttributes(typeof(NameAttribute), false),
3 eva 145 (f, a) => new {Field = f, Att = a}).SingleOrDefault(f => f.Field.GetValue(structure).Equals(item));
146 return field != null ? ((NameAttribute) field.Att).Name : string.Empty;
2 zed 147 }
3 eva 148  
7 office 149 ///////////////////////////////////////////////////////////////////////////
150 // Copyright (C) 2016 Wizardry and Steamworks - License: GNU GPLv3 //
151 ///////////////////////////////////////////////////////////////////////////
3 eva 152 /// <summary>
7 office 153 /// Get field or property from a class by supplying a path.
154 /// </summary>
155 /// <typeparam name="T">the type of the object</typeparam>
156 /// <param name="o">the object</param>
157 /// <param name="path">the fully qualified path to the field of property</param>
158 /// <returns>
159 /// the last object in the fully qualified path or null in case the field or property could not be found
160 /// </returns>
161 public static object GetFP<T>(this T o, string path)
162 {
163 if (string.IsNullOrEmpty(path)) return null;
164 if (o == null) return null;
165  
166 var memberType = o.GetType();
167 var components = path.Split('.');
168  
169 var f = memberType.GetRuntimeField(components[0]);
170 var p = memberType.GetRuntimeProperty(components[0]);
171  
172 if (f != null)
173 return components.Length > 1
174 ? GetFP(f.GetValue(o),
175 components.Skip(1).Aggregate((a, i) => a + @"." + i))
176 : memberType.GetRuntimeField(path).GetValue(o);
177  
178 if (p != null)
179 return components.Length > 1
180 ? GetFP(p.GetValue(o),
181 components.Skip(1).Aggregate((a, i) => a + @"." + i))
182 : memberType.GetRuntimeProperty(path).GetValue(o);
183  
184 return null;
185 }
186  
187 ///////////////////////////////////////////////////////////////////////////
188 // Copyright (C) 2016 Wizardry and Steamworks - License: GNU GPLv3 //
189 ///////////////////////////////////////////////////////////////////////////
190 /// <summary>
191 /// Get field or property info from a class by supplying a path.
192 /// </summary>
193 /// <typeparam name="T">the type of the object</typeparam>
194 /// <param name="o">the object</param>
195 /// <param name="path">the fully qualified path to the field of property</param>
196 /// <returns>
197 /// the field or property info of the last object in the path or null if the object cannot be found
198 /// </returns>
199 public static object GetFPInfo<T>(this T o, string path)
200 {
201 if (string.IsNullOrEmpty(path)) return null;
202 if (o == null) return null;
203  
204 var memberType = o.GetType();
205 var components = path.Split('.');
206  
207 var f = memberType.GetRuntimeField(components[0]);
208 var p = memberType.GetRuntimeProperty(components[0]);
209  
210 if (f != null)
211 return components.Length > 1
212 ? GetFPInfo(f.GetValue(o),
213 components.Skip(1).Aggregate((a, i) => a + @"." + i))
214 : memberType.GetRuntimeField(path);
215  
216 if (p != null)
217 return components.Length > 1
218 ? GetFPInfo(p.GetValue(o),
219 components.Skip(1).Aggregate((a, i) => a + @"." + i))
220 : memberType.GetRuntimeProperty(path);
221  
222 return null;
223 }
224  
225 ///////////////////////////////////////////////////////////////////////////
226 // Copyright (C) 2016 Wizardry and Steamworks - License: GNU GPLv3 //
227 ///////////////////////////////////////////////////////////////////////////
19 office 228 /// <summary>Return all the run-time properties for an object.</summary>
229 /// <param name="o">the object whose properties to return</param>
230 /// <returns>the property information for all the properties of the object</returns>
231 public static IEnumerable<PropertyInfo> GetPropertiesInfo<T>(this T o)
232 {
233 foreach (var p in o.GetType().GetRuntimeProperties())
234 yield return p;
235 }
236  
237 ///////////////////////////////////////////////////////////////////////////
238 // Copyright (C) 2016 Wizardry and Steamworks - License: GNU GPLv3 //
239 ///////////////////////////////////////////////////////////////////////////
7 office 240 /// <summary>
241 /// Enumerate all the base types recursively starting from a type.
242 /// </summary>
243 /// <param name="type">the type</param>
244 /// <returns>an enumeration of all base types</returns>
245 public static IEnumerable<Type> GetBaseTypes(this Type type)
246 {
247 var baseType = type.GetTypeInfo().BaseType;
10 office 248 if (baseType == null)
7 office 249 yield break;
250 yield return baseType;
251 foreach (var t in GetBaseTypes(baseType))
252 {
253 yield return t;
254 }
255 }
256  
257 /// <summary>
3 eva 258 /// A generic name attribute.
259 /// </summary>
260 public class NameAttribute : Attribute
261 {
262 protected readonly string name;
263  
264 public NameAttribute(string name)
265 {
266 this.name = name;
267 }
268  
269 public string Name => name;
270 }
271  
272 /// <summary>
273 /// A generic description attribute.
274 /// </summary>
275 public class DescriptionAttribute : Attribute
276 {
277 protected readonly string description;
278  
279 public DescriptionAttribute(string description)
280 {
281 this.description = description;
282 }
283  
284 public string Description => description;
285 }
2 zed 286 }
3 eva 287 }