libxmltv/Core/ThrowHelper.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Security;
using System.Runtime.Serialization;
using System.Runtime.CompilerServices;

namespace libxmltv.Core
{
    internal static class ThrowHelper
    {
        // Methods
        internal static string GetArgumentName(ExceptionArgument argument)
        {
            switch (argument)
            {
                case ExceptionArgument.obj:
                    return "obj";

                case ExceptionArgument.dictionary:
                    return "dictionary";

                case ExceptionArgument.dictionaryCreationThreshold:
                    return "dictionaryCreationThreshold";

                case ExceptionArgument.array:
                    return "array";

                case ExceptionArgument.info:
                    return "info";

                case ExceptionArgument.key:
                    return "key";

                case ExceptionArgument.collection:
                    return "collection";

                case ExceptionArgument.list:
                    return "list";

                case ExceptionArgument.match:
                    return "match";

                case ExceptionArgument.converter:
                    return "converter";

                case ExceptionArgument.queue:
                    return "queue";

                case ExceptionArgument.stack:
                    return "stack";

                case ExceptionArgument.capacity:
                    return "capacity";

                case ExceptionArgument.index:
                    return "index";

                case ExceptionArgument.startIndex:
                    return "startIndex";

                case ExceptionArgument.value:
                    return "value";

                case ExceptionArgument.count:
                    return "count";

                case ExceptionArgument.arrayIndex:
                    return "arrayIndex";

                case ExceptionArgument.name:
                    return "name";

                case ExceptionArgument.mode:
                    return "mode";
            }
            return string.Empty;
        }

        internal static string GetResourceName(ExceptionResource resource)
        {
            switch (resource)
            {
                case ExceptionResource.Argument_ImplementIComparable:
                    return "Argument_ImplementIComparable";

                case ExceptionResource.Argument_InvalidType:
                    return "Argument_InvalidType";

                case ExceptionResource.Argument_InvalidArgumentForComparison:
                    return "Argument_InvalidArgumentForComparison";

                case ExceptionResource.Argument_InvalidRegistryKeyPermissionCheck:
                    return "Argument_InvalidRegistryKeyPermissionCheck";

                case ExceptionResource.ArgumentOutOfRange_NeedNonNegNum:
                    return "ArgumentOutOfRange_NeedNonNegNum";

                case ExceptionResource.Arg_ArrayPlusOffTooSmall:
                    return "Arg_ArrayPlusOffTooSmall";

                case ExceptionResource.Arg_NonZeroLowerBound:
                    return "Arg_NonZeroLowerBound";

                case ExceptionResource.Arg_RankMultiDimNotSupported:
                    return "Arg_RankMultiDimNotSupported";

                case ExceptionResource.Arg_RegKeyDelHive:
                    return "Arg_RegKeyDelHive";

                case ExceptionResource.Arg_RegKeyStrLenBug:
                    return "Arg_RegKeyStrLenBug";

                case ExceptionResource.Arg_RegSetStrArrNull:
                    return "Arg_RegSetStrArrNull";

                case ExceptionResource.Arg_RegSetMismatchedKind:
                    return "Arg_RegSetMismatchedKind";

                case ExceptionResource.Arg_RegSubKeyAbsent:
                    return "Arg_RegSubKeyAbsent";

                case ExceptionResource.Arg_RegSubKeyValueAbsent:
                    return "Arg_RegSubKeyValueAbsent";

                case ExceptionResource.Argument_AddingDuplicate:
                    return "Argument_AddingDuplicate";

                case ExceptionResource.Serialization_InvalidOnDeser:
                    return "Serialization_InvalidOnDeser";

                case ExceptionResource.Serialization_MissingKeyValuePairs:
                    return "Serialization_MissingKeyValuePairs";

                case ExceptionResource.Serialization_NullKey:
                    return "Serialization_NullKey";

                case ExceptionResource.Argument_InvalidArrayType:
                    return "Argument_InvalidArrayType";

                case ExceptionResource.NotSupported_KeyCollectionSet:
                    return "NotSupported_KeyCollectionSet";

                case ExceptionResource.NotSupported_ValueCollectionSet:
                    return "NotSupported_ValueCollectionSet";

                case ExceptionResource.ArgumentOutOfRange_SmallCapacity:
                    return "ArgumentOutOfRange_SmallCapacity";

                case ExceptionResource.ArgumentOutOfRange_Index:
                    return "ArgumentOutOfRange_Index";

                case ExceptionResource.Argument_InvalidOffLen:
                    return "Argument_InvalidOffLen";

                case ExceptionResource.Argument_ItemNotExist:
                    return "Argument_ItemNotExist";

                case ExceptionResource.ArgumentOutOfRange_Count:
                    return "ArgumentOutOfRange_Count";

                case ExceptionResource.ArgumentOutOfRange_InvalidThreshold:
                    return "ArgumentOutOfRange_InvalidThreshold";

                case ExceptionResource.ArgumentOutOfRange_ListInsert:
                    return "ArgumentOutOfRange_ListInsert";

                case ExceptionResource.NotSupported_ReadOnlyCollection:
                    return "NotSupported_ReadOnlyCollection";

                case ExceptionResource.InvalidOperation_CannotRemoveFromStackOrQueue:
                    return "InvalidOperation_CannotRemoveFromStackOrQueue";

                case ExceptionResource.InvalidOperation_EmptyQueue:
                    return "InvalidOperation_EmptyQueue";

                case ExceptionResource.InvalidOperation_EnumOpCantHappen:
                    return "InvalidOperation_EnumOpCantHappen";

                case ExceptionResource.InvalidOperation_EnumFailedVersion:
                    return "InvalidOperation_EnumFailedVersion";

                case ExceptionResource.InvalidOperation_EmptyStack:
                    return "InvalidOperation_EmptyStack";

                case ExceptionResource.ArgumentOutOfRange_BiggerThanCollection:
                    return "ArgumentOutOfRange_BiggerThanCollection";

                case ExceptionResource.InvalidOperation_EnumNotStarted:
                    return "InvalidOperation_EnumNotStarted";

                case ExceptionResource.InvalidOperation_EnumEnded:
                    return "InvalidOperation_EnumEnded";

                case ExceptionResource.NotSupported_SortedListNestedWrite:
                    return "NotSupported_SortedListNestedWrite";

                case ExceptionResource.InvalidOperation_NoValue:
                    return "InvalidOperation_NoValue";

                case ExceptionResource.InvalidOperation_RegRemoveSubKey:
                    return "InvalidOperation_RegRemoveSubKey";

                case ExceptionResource.Security_RegistryPermission:
                    return "Security_RegistryPermission";

                case ExceptionResource.UnauthorizedAccess_RegistryNoWrite:
                    return "UnauthorizedAccess_RegistryNoWrite";

                case ExceptionResource.ObjectDisposed_RegKeyClosed:
                    return "ObjectDisposed_RegKeyClosed";

                case ExceptionResource.NotSupported_InComparableType:
                    return "NotSupported_InComparableType";
            }
            return string.Empty;
        }

        internal static void ThrowArgumentException(ExceptionResource resource)
        {
            throw new ArgumentException(Environment.GetResourceString(GetResourceName(resource)));
        }

        internal static void ThrowArgumentException(ExceptionResource resource, ExceptionArgument argument)
        {
            throw new ArgumentException(Environment.GetResourceString(GetResourceName(resource)), GetArgumentName(argument));
        }

        internal static void ThrowArgumentNullException(ExceptionArgument argument)
        {
            throw new ArgumentNullException(GetArgumentName(argument));
        }

        [MethodImpl(MethodImplOptions.NoInlining)]
        internal static void ThrowArgumentOutOfRangeException()
        {
            ThrowArgumentOutOfRangeException(ExceptionArgument.index, ExceptionResource.ArgumentOutOfRange_Index);
        }

        internal static void ThrowArgumentOutOfRangeException(ExceptionArgument argument)
        {
            throw new ArgumentOutOfRangeException(GetArgumentName(argument));
        }

        internal static void ThrowArgumentOutOfRangeException(ExceptionArgument argument, ExceptionResource resource)
        {
            throw new ArgumentOutOfRangeException(GetArgumentName(argument), Environment.GetResourceString(GetResourceName(resource)));
        }

        internal static void ThrowInvalidOperationException(ExceptionResource resource)
        {
            throw new InvalidOperationException(Environment.GetResourceString(GetResourceName(resource)));
        }

        internal static void ThrowKeyNotFoundException()
        {
            throw new KeyNotFoundException();
        }

        internal static void ThrowNotSupportedException(ExceptionResource resource)
        {
            throw new NotSupportedException(Environment.GetResourceString(GetResourceName(resource)));
        }

        internal static void ThrowObjectDisposedException(string objectName, ExceptionResource resource)
        {
            throw new ObjectDisposedException(objectName, Environment.GetResourceString(GetResourceName(resource)));
        }

        internal static void ThrowSecurityException(ExceptionResource resource)
        {
            throw new SecurityException(Environment.GetResourceString(GetResourceName(resource)));
        }

        internal static void ThrowSerializationException(ExceptionResource resource)
        {
            throw new SerializationException(Environment.GetResourceString(GetResourceName(resource)));
        }

        internal static void ThrowUnauthorizedAccessException(ExceptionResource resource)
        {
            throw new UnauthorizedAccessException(Environment.GetResourceString(GetResourceName(resource)));
        }

        internal static void ThrowWrongKeyTypeArgumentException(object key, Type targetType)
        {
            throw new ArgumentException(Environment.GetResourceString("Arg_WrongType", new object[] { key, targetType }), "key");
        }

        internal static void ThrowWrongValueTypeArgumentException(object value, Type targetType)
        {
            throw new ArgumentException(Environment.GetResourceString("Arg_WrongType", new object[] { value, targetType }), "value");
        }
    }
}
1	william	92	using System;
2			using System.Collections.Generic;
3			using System.Linq;
4			using System.Text;
5			using System.Security;
6			using System.Runtime.Serialization;
7			using System.Runtime.CompilerServices;
8
9			namespace libxmltv.Core
10			{
11			internal static class ThrowHelper
12			{
13			// Methods
14			internal static string GetArgumentName(ExceptionArgument argument)
15			{
16			switch (argument)
17			{
18			case ExceptionArgument.obj:
19			return "obj";
20
21			case ExceptionArgument.dictionary:
22			return "dictionary";
23
24			case ExceptionArgument.dictionaryCreationThreshold:
25			return "dictionaryCreationThreshold";
26
27			case ExceptionArgument.array:
28			return "array";
29
30			case ExceptionArgument.info:
31			return "info";
32
33			case ExceptionArgument.key:
34			return "key";
35
36			case ExceptionArgument.collection:
37			return "collection";
38
39			case ExceptionArgument.list:
40			return "list";
41
42			case ExceptionArgument.match:
43			return "match";
44
45			case ExceptionArgument.converter:
46			return "converter";
47
48			case ExceptionArgument.queue:
49			return "queue";
50
51			case ExceptionArgument.stack:
52			return "stack";
53
54			case ExceptionArgument.capacity:
55			return "capacity";
56
57			case ExceptionArgument.index:
58			return "index";
59
60			case ExceptionArgument.startIndex:
61			return "startIndex";
62
63			case ExceptionArgument.value:
64			return "value";
65
66			case ExceptionArgument.count:
67			return "count";
68
69			case ExceptionArgument.arrayIndex:
70			return "arrayIndex";
71
72			case ExceptionArgument.name:
73			return "name";
74
75			case ExceptionArgument.mode:
76			return "mode";
77			}
78			return string.Empty;
79			}
80
81			internal static string GetResourceName(ExceptionResource resource)
82			{
83			switch (resource)
84			{
85			case ExceptionResource.Argument_ImplementIComparable:
86			return "Argument_ImplementIComparable";
87
88			case ExceptionResource.Argument_InvalidType:
89			return "Argument_InvalidType";
90
91			case ExceptionResource.Argument_InvalidArgumentForComparison:
92			return "Argument_InvalidArgumentForComparison";
93
94			case ExceptionResource.Argument_InvalidRegistryKeyPermissionCheck:
95			return "Argument_InvalidRegistryKeyPermissionCheck";
96
97			case ExceptionResource.ArgumentOutOfRange_NeedNonNegNum:
98			return "ArgumentOutOfRange_NeedNonNegNum";
99
100			case ExceptionResource.Arg_ArrayPlusOffTooSmall:
101			return "Arg_ArrayPlusOffTooSmall";
102
103			case ExceptionResource.Arg_NonZeroLowerBound:
104			return "Arg_NonZeroLowerBound";
105
106			case ExceptionResource.Arg_RankMultiDimNotSupported:
107			return "Arg_RankMultiDimNotSupported";
108
109			case ExceptionResource.Arg_RegKeyDelHive:
110			return "Arg_RegKeyDelHive";
111
112			case ExceptionResource.Arg_RegKeyStrLenBug:
113			return "Arg_RegKeyStrLenBug";
114
115			case ExceptionResource.Arg_RegSetStrArrNull:
116			return "Arg_RegSetStrArrNull";
117
118			case ExceptionResource.Arg_RegSetMismatchedKind:
119			return "Arg_RegSetMismatchedKind";
120
121			case ExceptionResource.Arg_RegSubKeyAbsent:
122			return "Arg_RegSubKeyAbsent";
123
124			case ExceptionResource.Arg_RegSubKeyValueAbsent:
125			return "Arg_RegSubKeyValueAbsent";
126
127			case ExceptionResource.Argument_AddingDuplicate:
128			return "Argument_AddingDuplicate";
129
130			case ExceptionResource.Serialization_InvalidOnDeser:
131			return "Serialization_InvalidOnDeser";
132
133			case ExceptionResource.Serialization_MissingKeyValuePairs:
134			return "Serialization_MissingKeyValuePairs";
135
136			case ExceptionResource.Serialization_NullKey:
137			return "Serialization_NullKey";
138
139			case ExceptionResource.Argument_InvalidArrayType:
140			return "Argument_InvalidArrayType";
141
142			case ExceptionResource.NotSupported_KeyCollectionSet:
143			return "NotSupported_KeyCollectionSet";
144
145			case ExceptionResource.NotSupported_ValueCollectionSet:
146			return "NotSupported_ValueCollectionSet";
147
148			case ExceptionResource.ArgumentOutOfRange_SmallCapacity:
149			return "ArgumentOutOfRange_SmallCapacity";
150
151			case ExceptionResource.ArgumentOutOfRange_Index:
152			return "ArgumentOutOfRange_Index";
153
154			case ExceptionResource.Argument_InvalidOffLen:
155			return "Argument_InvalidOffLen";
156
157			case ExceptionResource.Argument_ItemNotExist:
158			return "Argument_ItemNotExist";
159
160			case ExceptionResource.ArgumentOutOfRange_Count:
161			return "ArgumentOutOfRange_Count";
162
163			case ExceptionResource.ArgumentOutOfRange_InvalidThreshold:
164			return "ArgumentOutOfRange_InvalidThreshold";
165
166			case ExceptionResource.ArgumentOutOfRange_ListInsert:
167			return "ArgumentOutOfRange_ListInsert";
168
169			case ExceptionResource.NotSupported_ReadOnlyCollection:
170			return "NotSupported_ReadOnlyCollection";
171
172			case ExceptionResource.InvalidOperation_CannotRemoveFromStackOrQueue:
173			return "InvalidOperation_CannotRemoveFromStackOrQueue";
174
175			case ExceptionResource.InvalidOperation_EmptyQueue:
176			return "InvalidOperation_EmptyQueue";
177
178			case ExceptionResource.InvalidOperation_EnumOpCantHappen:
179			return "InvalidOperation_EnumOpCantHappen";
180
181			case ExceptionResource.InvalidOperation_EnumFailedVersion:
182			return "InvalidOperation_EnumFailedVersion";
183
184			case ExceptionResource.InvalidOperation_EmptyStack:
185			return "InvalidOperation_EmptyStack";
186
187			case ExceptionResource.ArgumentOutOfRange_BiggerThanCollection:
188			return "ArgumentOutOfRange_BiggerThanCollection";
189
190			case ExceptionResource.InvalidOperation_EnumNotStarted:
191			return "InvalidOperation_EnumNotStarted";
192
193			case ExceptionResource.InvalidOperation_EnumEnded:
194			return "InvalidOperation_EnumEnded";
195
196			case ExceptionResource.NotSupported_SortedListNestedWrite:
197			return "NotSupported_SortedListNestedWrite";
198
199			case ExceptionResource.InvalidOperation_NoValue:
200			return "InvalidOperation_NoValue";
201
202			case ExceptionResource.InvalidOperation_RegRemoveSubKey:
203			return "InvalidOperation_RegRemoveSubKey";
204
205			case ExceptionResource.Security_RegistryPermission:
206			return "Security_RegistryPermission";
207
208			case ExceptionResource.UnauthorizedAccess_RegistryNoWrite:
209			return "UnauthorizedAccess_RegistryNoWrite";
210
211			case ExceptionResource.ObjectDisposed_RegKeyClosed:
212			return "ObjectDisposed_RegKeyClosed";
213
214			case ExceptionResource.NotSupported_InComparableType:
215			return "NotSupported_InComparableType";
216			}
217			return string.Empty;
218			}
219
220			internal static void ThrowArgumentException(ExceptionResource resource)
221			{
222			throw new ArgumentException(Environment.GetResourceString(GetResourceName(resource)));
223			}
224
225			internal static void ThrowArgumentException(ExceptionResource resource, ExceptionArgument argument)
226			{
227			throw new ArgumentException(Environment.GetResourceString(GetResourceName(resource)), GetArgumentName(argument));
228			}
229
230			internal static void ThrowArgumentNullException(ExceptionArgument argument)
231			{
232			throw new ArgumentNullException(GetArgumentName(argument));
233			}
234
235			[MethodImpl(MethodImplOptions.NoInlining)]
236			internal static void ThrowArgumentOutOfRangeException()
237			{
238			ThrowArgumentOutOfRangeException(ExceptionArgument.index, ExceptionResource.ArgumentOutOfRange_Index);
239			}
240
241			internal static void ThrowArgumentOutOfRangeException(ExceptionArgument argument)
242			{
243			throw new ArgumentOutOfRangeException(GetArgumentName(argument));
244			}
245
246			internal static void ThrowArgumentOutOfRangeException(ExceptionArgument argument, ExceptionResource resource)
247			{
248			throw new ArgumentOutOfRangeException(GetArgumentName(argument), Environment.GetResourceString(GetResourceName(resource)));
249			}
250
251			internal static void ThrowInvalidOperationException(ExceptionResource resource)
252			{
253			throw new InvalidOperationException(Environment.GetResourceString(GetResourceName(resource)));
254			}
255
256			internal static void ThrowKeyNotFoundException()
257			{
258			throw new KeyNotFoundException();
259			}
260
261			internal static void ThrowNotSupportedException(ExceptionResource resource)
262			{
263			throw new NotSupportedException(Environment.GetResourceString(GetResourceName(resource)));
264			}
265
266			internal static void ThrowObjectDisposedException(string objectName, ExceptionResource resource)
267			{
268			throw new ObjectDisposedException(objectName, Environment.GetResourceString(GetResourceName(resource)));
269			}
270
271			internal static void ThrowSecurityException(ExceptionResource resource)
272			{
273			throw new SecurityException(Environment.GetResourceString(GetResourceName(resource)));
274			}
275
276			internal static void ThrowSerializationException(ExceptionResource resource)
277			{
278			throw new SerializationException(Environment.GetResourceString(GetResourceName(resource)));
279			}
280
281			internal static void ThrowUnauthorizedAccessException(ExceptionResource resource)
282			{
283			throw new UnauthorizedAccessException(Environment.GetResourceString(GetResourceName(resource)));
284			}
285
286			internal static void ThrowWrongKeyTypeArgumentException(object key, Type targetType)
287			{
288			throw new ArgumentException(Environment.GetResourceString("Arg_WrongType", new object[] { key, targetType }), "key");
289			}
290
291			internal static void ThrowWrongValueTypeArgumentException(object value, Type targetType)
292			{
293			throw new ArgumentException(Environment.GetResourceString("Arg_WrongType", new object[] { value, targetType }), "value");
294			}
295			}
296			}