Enum

SUBMITTED BY: Guest

DATE: Aug. 1, 2014, 10:03 a.m.

FORMAT: C#

SIZE: 6.8 kB

Raw Download

HITS: 24901

Report
  1. using System;
  2. //using System.Collections.Generic;
  3. using System.ComponentModel;
  4. using System.IO;
  6. namespace Gibbed.IO
  7. {
  8. public static partial class StreamHelpers
  9. {
  10. #region Cache
  11. private static class EnumTypeCache
  12. {
  13. /*private static Dictionary<Type, EnumUnderlyingType> _Lookup;
  15. static EnumTypeCache()
  16. {
  17. _Lookup = new Dictionary<Type, EnumUnderlyingType>();
  18. }*/
  20. private static TypeCode TranslateType(Type type)
  21. {
  22. if (type.IsEnum == true)
  23. {
  24. var underlyingType = Enum.GetUnderlyingType(type);
  25. var underlyingTypeCode = Type.GetTypeCode(underlyingType);
  27. switch (underlyingTypeCode)
  28. {
  29. case TypeCode.SByte:
  30. case TypeCode.Byte:
  31. case TypeCode.Int16:
  32. case TypeCode.UInt16:
  33. case TypeCode.Int32:
  34. case TypeCode.UInt32:
  35. case TypeCode.Int64:
  36. case TypeCode.UInt64:
  37. {
  38. return underlyingTypeCode;
  39. }
  40. }
  41. }
  43. throw new ArgumentException("unknown enum type", "type");
  44. }
  46. public static TypeCode Get(Type type)
  47. {
  48. /*if (Lookup.ContainsKey(type) == true)
  49. {
  50. return Lookup[type];
  51. }*/
  53. return /*Lookup[type] =*/ TranslateType(type);
  54. }
  55. }
  56. #endregion
  58. #region ReadValueEnum
  59. public static T ReadValueEnum<T>(this Stream stream, Endian endian)
  60. {
  61. var type = typeof(T);
  63. object value;
  64. switch (EnumTypeCache.Get(type))
  65. {
  66. case TypeCode.SByte:
  67. {
  68. value = stream.ReadValueS8();
  69. break;
  70. }
  72. case TypeCode.Byte:
  73. {
  74. value = stream.ReadValueU8();
  75. break;
  76. }
  78. case TypeCode.Int16:
  79. {
  80. value = stream.ReadValueS16(endian);
  81. break;
  82. }
  84. case TypeCode.UInt16:
  85. {
  86. value = stream.ReadValueU16(endian);
  87. break;
  88. }
  90. case TypeCode.Int32:
  91. {
  92. value = stream.ReadValueS32(endian);
  93. break;
  94. }
  96. case TypeCode.UInt32:
  97. {
  98. value = stream.ReadValueU32(endian);
  99. break;
  100. }
  102. case TypeCode.Int64:
  103. {
  104. value = stream.ReadValueS64(endian);
  105. break;
  106. }
  108. case TypeCode.UInt64:
  109. {
  110. value = stream.ReadValueU64(endian);
  111. break;
  112. }
  114. default:
  115. {
  116. throw new NotSupportedException();
  117. }
  118. }
  120. return (T)Enum.ToObject(type, value);
  121. }
  123. public static T ReadValueEnum<T>(this Stream stream)
  124. {
  125. return stream.ReadValueEnum<T>(Endian.Little);
  126. }
  127. #endregion
  129. #region WriteValueEnum
  130. public static void WriteValueEnum<T>(this Stream stream, object value, Endian endian)
  131. {
  132. var type = typeof(T);
  133. switch (EnumTypeCache.Get(type))
  134. {
  135. case TypeCode.SByte:
  136. {
  137. stream.WriteValueS8((sbyte)value);
  138. break;
  139. }
  141. case TypeCode.Byte:
  142. {
  143. stream.WriteValueU8((byte)value);
  144. break;
  145. }
  147. case TypeCode.Int16:
  148. {
  149. stream.WriteValueS16((short)value, endian);
  150. break;
  151. }
  153. case TypeCode.UInt16:
  154. {
  155. stream.WriteValueU16((ushort)value, endian);
  156. break;
  157. }
  159. case TypeCode.Int32:
  160. {
  161. stream.WriteValueS32((int)value, endian);
  162. break;
  163. }
  165. case TypeCode.UInt32:
  166. {
  167. stream.WriteValueU32((uint)value, endian);
  168. break;
  169. }
  171. case TypeCode.Int64:
  172. {
  173. stream.WriteValueS64((long)value, endian);
  174. break;
  175. }
  177. case TypeCode.UInt64:
  178. {
  179. stream.WriteValueU64((ulong)value, endian);
  180. break;
  181. }
  183. default:
  184. {
  185. throw new NotSupportedException();
  186. }
  187. }
  188. }
  190. public static void WriteValueEnum<T>(this Stream stream, object value)
  191. {
  192. stream.WriteValueEnum<T>(value, Endian.Little);
  193. }
  194. #endregion
  196. #region Obsolete
  197. [Obsolete("use Endian enum instead of boolean to represent endianness")]
  198. [EditorBrowsable(EditorBrowsableState.Never)]
  199. public static T ReadValueEnum<T>(this Stream stream, bool littleEndian)
  200. {
  201. return stream.ReadValueEnum<T>(littleEndian == true ? Endian.Little : Endian.Big);
  202. }
  204. [Obsolete("use Endian enum instead of boolean to represent endianness")]
  205. [EditorBrowsable(EditorBrowsableState.Never)]
  206. public static void WriteValueEnum<T>(this Stream stream, object value, bool littleEndian)
  207. {
  208. stream.WriteValueEnum<T>(value, littleEndian == true ? Endian.Little : Endian.Big);
  209. }
  210. #endregion
  211. }
  212. }
comments powered by Disqus