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
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
|
//------------------------------------------------------------------------------
// <copyright file="StdValidatorsAndConverters.cs" company="Microsoft">
// Copyright (c) Microsoft Corporation. All rights reserved.
// </copyright>
//------------------------------------------------------------------------------
using System;
using System.Configuration;
using System.ComponentModel;
namespace System.Web.Configuration {
// Common shared validators and type converter instances
internal static class StdValidatorsAndConverters {
static private TypeConverter s_infiniteTimeSpanConverter;
static private TypeConverter s_timeSpanMinutesConverter;
static private TypeConverter s_timeSpanMinutesOrInfiniteConverter;
static private TypeConverter s_timeSpanSecondsConverter;
static private TypeConverter s_timeSpanSecondsOrInfiniteConverter;
static private TypeConverter s_whiteSpaceTrimStringConverter;
static private TypeConverter s_versionConverter;
static private ConfigurationValidatorBase s_regexMatchTimeoutValidator;
static private ConfigurationValidatorBase s_positiveTimeSpanValidator;
static private ConfigurationValidatorBase s_nonEmptyStringValidator;
static private ConfigurationValidatorBase s_nonZeroPositiveIntegerValidator;
static private ConfigurationValidatorBase s_positiveIntegerValidator;
static internal TypeConverter InfiniteTimeSpanConverter {
get {
if (s_infiniteTimeSpanConverter == null) {
s_infiniteTimeSpanConverter = new InfiniteTimeSpanConverter();
}
return s_infiniteTimeSpanConverter;
}
}
static internal TypeConverter TimeSpanMinutesConverter {
get {
if (s_timeSpanMinutesConverter == null) {
s_timeSpanMinutesConverter = new TimeSpanMinutesConverter();
}
return s_timeSpanMinutesConverter;
}
}
static internal TypeConverter TimeSpanMinutesOrInfiniteConverter {
get {
if (s_timeSpanMinutesOrInfiniteConverter == null) {
s_timeSpanMinutesOrInfiniteConverter = new TimeSpanMinutesOrInfiniteConverter();
}
return s_timeSpanMinutesOrInfiniteConverter;
}
}
static internal TypeConverter TimeSpanSecondsConverter {
get {
if (s_timeSpanSecondsConverter == null) {
s_timeSpanSecondsConverter = new TimeSpanSecondsConverter();
}
return s_timeSpanSecondsConverter;
}
}
static internal TypeConverter TimeSpanSecondsOrInfiniteConverter {
get {
if (s_timeSpanSecondsOrInfiniteConverter == null) {
s_timeSpanSecondsOrInfiniteConverter = new TimeSpanSecondsOrInfiniteConverter();
}
return s_timeSpanSecondsOrInfiniteConverter;
}
}
static internal TypeConverter WhiteSpaceTrimStringConverter {
get {
if (s_whiteSpaceTrimStringConverter == null) {
s_whiteSpaceTrimStringConverter = new WhiteSpaceTrimStringConverter();
}
return s_whiteSpaceTrimStringConverter;
}
}
static internal TypeConverter VersionConverter {
get {
if (s_versionConverter == null) {
s_versionConverter = new VersionConverter();
}
return s_versionConverter;
}
}
static internal ConfigurationValidatorBase RegexMatchTimeoutValidator {
get {
if (s_regexMatchTimeoutValidator == null) {
s_regexMatchTimeoutValidator = new RegexMatchTimeoutValidator();
}
return s_regexMatchTimeoutValidator;
}
}
static internal ConfigurationValidatorBase PositiveTimeSpanValidator {
get {
if (s_positiveTimeSpanValidator == null) {
s_positiveTimeSpanValidator = new PositiveTimeSpanValidator();
}
return s_positiveTimeSpanValidator;
}
}
static internal ConfigurationValidatorBase NonEmptyStringValidator {
get {
if (s_nonEmptyStringValidator == null) {
s_nonEmptyStringValidator = new StringValidator(1);
}
return s_nonEmptyStringValidator;
}
}
static internal ConfigurationValidatorBase NonZeroPositiveIntegerValidator {
get {
if (s_nonZeroPositiveIntegerValidator == null) {
s_nonZeroPositiveIntegerValidator = new IntegerValidator(1, int.MaxValue);
}
return s_nonZeroPositiveIntegerValidator;
}
}
static internal ConfigurationValidatorBase PositiveIntegerValidator {
get {
if (s_positiveIntegerValidator == null) {
s_positiveIntegerValidator = new IntegerValidator(0, int.MaxValue);
}
return s_positiveIntegerValidator;
}
}
}
}
|
