1 files changed, 0 insertions, 93 deletions
diff --git a/csharp/src/ProtocolBuffers/EnumHelper.cs b/csharp/src/ProtocolBuffers/EnumHelper.cs
deleted file mode 100644
index 1cf18985..00000000
--- a/csharp/src/ProtocolBuffers/EnumHelper.cs
+++ /dev/null
@@ -1,93 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Linq.Expressions;
-using System.Text;
-
-namespace Google.Protobuf
-{
-    public class EnumHelper<T> where T : struct, IComparable, IFormattable
-    {
-        // TODO(jonskeet): For snmall enums, use something lighter-weight than a dictionary?
-        private static readonly Dictionary<int, T> _byNumber;
-        private static readonly Dictionary<string, T> _byName;
-        private static readonly Func<T, long> toRawValue;
-        private static readonly Func<long, T> fromRawValue;
-
-        private const long UnknownValueBase = 0x100000000L;
-
-        static EnumHelper()
-        {
-            if (!typeof(T).IsEnum)
-            {
-                throw new InvalidOperationException(string.Format("{0} is not an enum type", typeof(T).FullName));
-            }
-            if (Enum.GetUnderlyingType(typeof(T)) != typeof(long))
-            {
-                throw new InvalidOperationException(string.Format("{0} does not have long as an underlying type", typeof(T).FullName));
-            }
-            // It will actually be a T[], but the CLR will let us convert.
-            long[] array = (long[])Enum.GetValues(typeof(T));
-            _byNumber = new Dictionary<int, T>(array.Length);
-            foreach (long i in array)
-            {
-                _byNumber[(int) i] = (T)(object)i;
-            }
-            string[] names = (string[])Enum.GetNames(typeof(T));
-            _byName = new Dictionary<string, T>();
-            foreach (var name in names)
-            {
-                _byName[name] = (T) Enum.Parse(typeof(T), name, false);
-            }
-
-            ParameterExpression param1 = Expression.Parameter(typeof(T), "x");
-            ParameterExpression param2 = Expression.Parameter(typeof(long), "x");
-            Expression convertedParam1 = Expression.Convert(param1, typeof(long));
-            Expression convertedParam2 = Expression.Convert(param2, typeof(T));
-            toRawValue = Expression.Lambda<Func<T, long>>(convertedParam1, param1).Compile();
-            fromRawValue = Expression.Lambda<Func<long, T>>(convertedParam2, param2).Compile();
-        }
-
-        /// <summary>
-        /// Converts the given 32-bit integer into a value of the enum type.
-        /// If the integer is a known, named value, that is returned; otherwise,
-        /// a value which is outside the range of 32-bit integers but which preserves
-        /// the original integer is returned.
-        /// </summary>
-        public static T FromInt32(int value)
-        {
-            T validValue;
-            return _byNumber.TryGetValue(value, out validValue) ? validValue : FromRawValue((long) value | UnknownValueBase);
-        }
-
-        /// <summary>
-        /// Converts a value of the enum type to a 32-bit integer. This reverses
-        /// <see cref="Int32"/>.
-        /// </summary>
-        public static int ToInt32(T value)
-        {
-            return (int)GetRawValue(value);
-        }
-
-        public static bool IsKnownValue(T value)
-        {
-            long raw = GetRawValue(value);
-            if (raw >= int.MinValue && raw <= int.MaxValue)
-            {
-                return _byNumber.ContainsKey((int)raw);
-            }
-            return false;
-        }
-
-        private static long GetRawValue(T value)
-        {
-            return toRawValue(value);
-        }
-
-        private static T FromRawValue(long value)
-        {
-            return fromRawValue(value);
-        }
-
-    }
-}