1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
|
//------------------------------------------------------------------------------
// Copyright (c) Microsoft Corporation. All rights reserved.
//------------------------------------------------------------------------------
namespace System.ServiceModel.Configuration
{
using System;
using System.Configuration;
[AttributeUsage(AttributeTargets.Property)]
internal sealed class StandardRuntimeFlagEnumValidatorAttribute : ConfigurationValidatorAttribute
{
Type enumType;
Type validatorType;
public StandardRuntimeFlagEnumValidatorAttribute(Type enumType)
{
StandardRuntimeFlagEnumValidatorAttribute.ValidateFlagEnumType(enumType);
this.EnumType = enumType;
}
public Type EnumType
{
get { return this.enumType; }
set
{
StandardRuntimeFlagEnumValidatorAttribute.ValidateFlagEnumType(value);
this.enumType = value;
}
}
static bool IsPowerOfTwo(int value)
{
return value > 0 && (value & (value - 1)) == 0;
}
internal static void ValidateFlagEnumType(Type value)
{
if (value == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("EnumType");
}
bool hasFlags = value.GetCustomAttributes(typeof(FlagsAttribute), true).Length > 0;
if (!value.IsEnum || !hasFlags)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgument("EnumType", SR.GetString(SR.FlagEnumTypeExpected, value));
}
int[] values = (int[])Enum.GetValues(value);
if (values != null &&
values.Length > 0)
{
for (int i = 0; i < values.Length; i++)
{
if (values[i] != 0 && !IsPowerOfTwo(values[i]))
{
if (!StandardRuntimeFlagEnumValidatorAttribute.IsCombinedValue(values[i], values, i - 1))
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgument("EnumType", SR.GetString(SR.InvalidFlagEnumType));
}
}
}
}
}
internal static bool IsCombinedValue(int combinedValue, int[] allowedValues, int startPosition)
{
int n = startPosition;
while (n >= 0 &&
combinedValue > 0)
{
if ((combinedValue & allowedValues[n]) == allowedValues[n])
{
combinedValue -= allowedValues[n];
}
n--;
}
return combinedValue == 0;
}
private void EnsureValidatorType()
{
if (this.validatorType == null)
{
validatorType = typeof(StandardRuntimeFlagEnumValidator<>).MakeGenericType(new System.Type[] { this.enumType });
}
}
public override ConfigurationValidatorBase ValidatorInstance
{
get
{
this.EnsureValidatorType();
return (ConfigurationValidatorBase)Activator.CreateInstance(validatorType, null);
}
}
}
}
|
