2 // System.Xml.Schema.XmlSchemaDatatype.cs
7 // (C)2003 Atsushi Enomoto
11 // Permission is hereby granted, free of charge, to any person obtaining
12 // a copy of this software and associated documentation files (the
13 // "Software"), to deal in the Software without restriction, including
14 // without limitation the rights to use, copy, modify, merge, publish,
15 // distribute, sublicense, and/or sell copies of the Software, and to
16 // permit persons to whom the Software is furnished to do so, subject to
17 // the following conditions:
19 // The above copyright notice and this permission notice shall be
20 // included in all copies or substantial portions of the Software.
22 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
23 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
24 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
25 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
26 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
27 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
28 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
31 using System
.Collections
;
34 using System
.Xml
.Schema
;
35 using System
.Globalization
;
36 using System
.Security
.Cryptography
;
39 using NSResolver
= System
.Xml
.IXmlNamespaceResolver
;
41 using NSResolver
= System
.Xml
.XmlNamespaceManager
;
45 namespace Mono
.Xml
.Schema
47 internal enum XsdWhitespaceFacet
54 internal enum XsdOrderedFacet
61 internal enum XsdOrdering
69 internal class XsdAnySimpleType
: XmlSchemaDatatype
71 static XsdAnySimpleType instance
;
72 static XsdAnySimpleType ()
74 instance
= new XsdAnySimpleType ();
77 public static XsdAnySimpleType Instance
{
78 get { return instance; }
82 public override XmlTypeCode TypeCode
{
83 get { return XmlTypeCode.AnyAtomicType; }
87 static readonly char [] whitespaceArray
= new char [] {' '}
;
90 public virtual bool Bounded
{
94 public virtual bool Finite
{
98 public virtual bool Numeric
{
102 public virtual XsdOrderedFacet Ordered
{
103 get { return XsdOrderedFacet.False; }
106 public override Type ValueType
{
107 #if BUGGY_MS_COMPLIANT
108 get { return typeof (string); }
110 get { return typeof (object); }
114 public override XmlTokenizedType TokenizedType
{
116 return XmlTokenizedType
.None
;
120 public override object ParseValue (string s
,
121 XmlNameTable nameTable
, NSResolver nsmgr
)
123 return Normalize (s
);
126 internal override ValueType
ParseValueType (string s
,
127 XmlNameTable nameTable
, NSResolver nsmgr
)
129 return new StringValueType (Normalize (s
));
132 internal string [] ParseListValue (string s
, XmlNameTable nameTable
)
134 return this.Normalize (s
, XsdWhitespaceFacet
.Collapse
).Split (whitespaceArray
);
139 // Can you even use XsdAnySimpleType in a schema?
140 // -> Yes. See E1-22 of http://www.w3.org/2001/05/xmlschema-errata#Errata1 (somewhat paranoid ;-)
142 internal bool AllowsFacet(XmlSchemaFacet xsf
) {
143 return (AllowedFacets
& xsf
.ThisFacet
)!=0;
148 internal virtual XsdOrdering
Compare(object x
, object y
) {
149 return XsdOrdering
.Indeterminate
;
152 internal virtual int Length(string s
) {
157 // anySimpleType allows any facet
158 internal virtual XmlSchemaFacet
.Facet AllowedFacets
{
159 get { return XmlSchemaFacet.AllFacets ;}
162 /* Matches facets allowed on boolean type
164 internal static readonly XmlSchemaFacet
.Facet booleanAllowedFacets
=
165 XmlSchemaFacet
.Facet
.pattern
| XmlSchemaFacet
.Facet
.whiteSpace
;
167 /* Matches facets allowed on decimal type.
169 internal static readonly XmlSchemaFacet
.Facet decimalAllowedFacets
=
170 XmlSchemaFacet
.Facet
.pattern
| XmlSchemaFacet
.Facet
.enumeration
|
171 XmlSchemaFacet
.Facet
.whiteSpace
| XmlSchemaFacet
.Facet
.maxInclusive
|
172 XmlSchemaFacet
.Facet
.minInclusive
| XmlSchemaFacet
.Facet
.maxExclusive
|
173 XmlSchemaFacet
.Facet
.minExclusive
| XmlSchemaFacet
.Facet
.fractionDigits
|
174 XmlSchemaFacet
.Facet
.totalDigits
;
176 /* Matches facets allowed on float, double, duration, dateTime, time, date,
177 * gYearMonth, gYear, gMonthDay, gMonth, and gDay types
180 internal static readonly XmlSchemaFacet
.Facet durationAllowedFacets
=
181 XmlSchemaFacet
.Facet
.pattern
| XmlSchemaFacet
.Facet
.enumeration
|
182 XmlSchemaFacet
.Facet
.whiteSpace
| XmlSchemaFacet
.Facet
.maxInclusive
|
183 XmlSchemaFacet
.Facet
.minInclusive
| XmlSchemaFacet
.Facet
.maxExclusive
|
184 XmlSchemaFacet
.Facet
.minExclusive
;
186 /* Matches facet allowed on string, hexBinary, base64Binary,
187 * anyURI, QName and NOTATION types
189 * Also used on list types
192 internal static readonly XmlSchemaFacet
.Facet stringAllowedFacets
=
193 XmlSchemaFacet
.Facet
.length
| XmlSchemaFacet
.Facet
.minLength
|
194 XmlSchemaFacet
.Facet
.maxLength
| XmlSchemaFacet
.Facet
.pattern
|
195 XmlSchemaFacet
.Facet
.enumeration
| XmlSchemaFacet
.Facet
.whiteSpace
;
199 internal class XdtAnyAtomicType
: XsdAnySimpleType
201 internal XdtAnyAtomicType ()
205 public override XmlTypeCode TypeCode
{
206 get { return XmlTypeCode.AnyAtomicType; }
210 internal class XdtUntypedAtomic
: XdtAnyAtomicType
212 internal XdtUntypedAtomic ()
216 public override XmlTypeCode TypeCode
{
217 get { return XmlTypeCode.UntypedAtomic; }
223 internal class XsdString
: XsdAnySimpleType
225 internal XsdString ()
229 internal override XmlSchemaFacet
.Facet AllowedFacets
{
230 get { return stringAllowedFacets; }
233 public override XmlTokenizedType TokenizedType
{
234 get { return XmlTokenizedType.CDATA; }
238 public override XmlTypeCode TypeCode
{
239 get { return XmlTypeCode.String; }
243 public override Type ValueType
{
244 get { return typeof (string); }
247 // Fundamental Facets
248 public override bool Bounded
{
249 get { return false; }
251 public override bool Finite
{
252 get { return false; }
254 public override bool Numeric
{
255 get { return false; }
257 public override XsdOrderedFacet Ordered
{
258 get { return XsdOrderedFacet.False; }
263 // xs:normalizedString
264 internal class XsdNormalizedString
: XsdString
266 internal XsdNormalizedString ()
268 this.WhitespaceValue
= XsdWhitespaceFacet
.Replace
;
271 public override XmlTokenizedType TokenizedType
{
273 get { return XmlTokenizedType.CDATA; }
277 public override XmlTypeCode TypeCode
{
278 get { return XmlTypeCode.NormalizedString; }
282 public override Type ValueType
{
283 get { return typeof (string); }
286 // ParseValue () method is as same as that of xs:string
290 internal class XsdToken
: XsdNormalizedString
294 this.WhitespaceValue
= XsdWhitespaceFacet
.Collapse
;
297 public override XmlTokenizedType TokenizedType
{
298 get { return XmlTokenizedType.CDATA; }
302 public override XmlTypeCode TypeCode
{
303 get { return XmlTypeCode.Token; }
307 public override Type ValueType
{
308 get { return typeof (string); }
311 // ParseValue () method is as same as that of xs:string
315 internal class XsdLanguage
: XsdToken
317 internal XsdLanguage ()
321 public override XmlTokenizedType TokenizedType
{
322 get { return XmlTokenizedType.CDATA; }
326 public override XmlTypeCode TypeCode
{
327 get { return XmlTypeCode.Language; }
331 public override Type ValueType
{
332 get { return typeof (string); }
335 // ParseValue () method is as same as that of xs:string
339 internal class XsdNMToken
: XsdToken
341 internal XsdNMToken ()
345 public override XmlTokenizedType TokenizedType
{
346 get { return XmlTokenizedType.NMTOKEN; }
350 public override XmlTypeCode TypeCode
{
351 get { return XmlTypeCode.NmToken; }
355 public override Type ValueType
{
356 get { return typeof (string); }
359 public override object ParseValue (string s
,
360 XmlNameTable nameTable
, NSResolver nsmgr
)
362 if (!XmlChar
.IsNmToken (s
))
363 throw new ArgumentException ("'" + s
+ "' is an invalid NMTOKEN.");
367 internal override ValueType
ParseValueType (string s
, XmlNameTable nameTable
, NSResolver nsmgr
)
369 return new StringValueType (ParseValue (s
, nameTable
, nsmgr
) as string);
374 internal class XsdNMTokens
: XsdNMToken
376 internal XsdNMTokens ()
380 public override XmlTokenizedType TokenizedType
{
381 get { return XmlTokenizedType.NMTOKENS; }
386 public override XmlTypeCode TypeCode
{
387 get { return XmlTypeCode.Item; }
391 public override Type ValueType
{
392 get { return typeof (string []); }
395 public override object ParseValue (string value, XmlNameTable nt
, NSResolver nsmgr
)
397 return GetValidatedArray (value, nt
);
400 internal override ValueType
ParseValueType (string s
, XmlNameTable nameTable
, NSResolver nsmgr
)
402 return new StringArrayValueType (GetValidatedArray (s
, nameTable
));
405 private string [] GetValidatedArray (string value, XmlNameTable nt
)
407 string [] nmtokens
= ParseListValue (value, nt
);
408 for (int i
= 0; i
< nmtokens
.Length
; i
++)
409 if (!XmlChar
.IsNmToken (nmtokens
[i
]))
410 throw new ArgumentException ("Invalid name token.");
416 internal class XsdName
: XsdToken
422 public override XmlTokenizedType TokenizedType
{
423 get { return XmlTokenizedType.CDATA; }
427 public override XmlTypeCode TypeCode
{
428 get { return XmlTypeCode.Name; }
432 public override Type ValueType
{
433 get { return typeof (string); }
436 public override object ParseValue (string s
,
437 XmlNameTable nameTable
, NSResolver nsmgr
)
439 if (!XmlChar
.IsName (s
))
440 throw new ArgumentException ("'" + s
+ "' is an invalid name.");
444 internal override ValueType
ParseValueType (string s
, XmlNameTable nameTable
, NSResolver nsmgr
)
446 return new StringValueType (ParseValue (s
, nameTable
, nsmgr
) as string);
451 internal class XsdNCName
: XsdName
453 internal XsdNCName ()
457 public override XmlTokenizedType TokenizedType
{
458 get { return XmlTokenizedType.NCName; }
462 public override XmlTypeCode TypeCode
{
463 get { return XmlTypeCode.NCName; }
467 public override Type ValueType
{
468 get { return typeof (string); }
471 public override object ParseValue (string s
,
472 XmlNameTable nameTable
, NSResolver nsmgr
)
474 if (!XmlChar
.IsNCName (s
))
475 throw new ArgumentException ("'" + s
+ "' is an invalid NCName.");
479 internal override ValueType
ParseValueType (string s
, XmlNameTable nameTable
, NSResolver nsmgr
)
481 return new StringValueType (ParseValue (s
, nameTable
, nsmgr
) as string);
486 internal class XsdID
: XsdName
492 public override XmlTokenizedType TokenizedType
{
493 get { return XmlTokenizedType.ID; }
497 public override XmlTypeCode TypeCode
{
498 get { return XmlTypeCode.Id; }
502 public override Type ValueType
{
503 get { return typeof (string); }
506 public override object ParseValue (string s
, XmlNameTable nt
, NSResolver nsmgr
)
508 if (!XmlChar
.IsNCName (s
))
509 throw new ArgumentException ("'" + s
+ "' is an invalid NCName.");
515 internal class XsdIDRef
: XsdName
521 public override XmlTokenizedType TokenizedType
{
522 get { return XmlTokenizedType.IDREF; }
526 public override XmlTypeCode TypeCode
{
527 get { return XmlTypeCode.Idref; }
531 public override Type ValueType
{
532 get { return typeof (string); }
535 public override object ParseValue (string s
, XmlNameTable nt
, NSResolver nsmgr
)
537 if (!XmlChar
.IsNCName (s
))
538 throw new ArgumentException ("'" + s
+ "' is an invalid NCName.");
544 internal class XsdIDRefs
: XsdName
546 internal XsdIDRefs ()
550 public override XmlTokenizedType TokenizedType
{
551 get { return XmlTokenizedType.IDREFS; }
556 public override XmlTypeCode TypeCode
{
557 get { return XmlTypeCode.Item; }
561 public override Type ValueType
{
562 get { return typeof (string []); }
565 public override object ParseValue (string value, XmlNameTable nt
, NSResolver nsmgr
)
567 return GetValidatedArray (value, nt
);
570 internal override ValueType
ParseValueType (string s
, XmlNameTable nameTable
, NSResolver nsmgr
)
572 return new StringArrayValueType (GetValidatedArray (s
, nameTable
));
575 private string [] GetValidatedArray (string value, XmlNameTable nt
)
577 string [] idrefs
= ParseListValue (value, nt
);
578 for (int i
= 0; i
< idrefs
.Length
; i
++)
579 XmlConvert
.VerifyNCName (idrefs
[i
]);
585 internal class XsdEntity
: XsdName
587 internal XsdEntity ()
591 public override XmlTokenizedType TokenizedType
{
592 get { return XmlTokenizedType.ENTITY; }
596 public override XmlTypeCode TypeCode
{
597 get { return XmlTypeCode.Entity; }
601 public override Type ValueType
{
602 get { return typeof (string); }
610 internal class XsdEntities
: XsdName
612 internal XsdEntities ()
616 public override XmlTokenizedType TokenizedType
{
617 get { return XmlTokenizedType.ENTITIES; }
622 public override XmlTypeCode TypeCode
{
623 get { return XmlTypeCode.Item; }
627 public override Type ValueType
{
628 get { return typeof (string []); }
631 public override object ParseValue (string value, XmlNameTable nt
, NSResolver nsmgr
)
633 return GetValidatedArray (value, nt
);
636 internal override ValueType
ParseValueType (string s
, XmlNameTable nameTable
, NSResolver nsmgr
)
638 return new StringArrayValueType (GetValidatedArray (s
, nameTable
));
641 private string [] GetValidatedArray (string value, XmlNameTable nt
)
643 string [] entities
= ParseListValue (value, nt
);
644 for (int i
= 0; i
< entities
.Length
; i
++)
645 if (!XmlChar
.IsName (entities
[i
]))
646 throw new ArgumentException ("Invalid entitiy name.");
652 internal class XsdNotation
: XsdAnySimpleType
654 internal XsdNotation ()
658 internal override XmlSchemaFacet
.Facet AllowedFacets
{
659 get { return stringAllowedFacets; }
662 public override XmlTokenizedType TokenizedType
{
663 get { return XmlTokenizedType.NOTATION; }
667 public override XmlTypeCode TypeCode
{
668 get { return XmlTypeCode.Notation; }
672 public override Type ValueType
{
673 get { return typeof (string); }
676 public override object ParseValue (string s
,
677 XmlNameTable nameTable
, NSResolver nsmgr
)
679 return Normalize (s
);
682 // Fundamental Facets
683 public override bool Bounded
{
684 get { return false; }
686 public override bool Finite
{
687 get { return false; }
689 public override bool Numeric
{
690 get { return false; }
692 public override XsdOrderedFacet Ordered
{
693 get { return XsdOrderedFacet.False; }
699 internal class XsdDecimal
: XsdAnySimpleType
701 internal XsdDecimal ()
703 this.WhitespaceValue
= XsdWhitespaceFacet
.Collapse
;
706 internal override XmlSchemaFacet
.Facet AllowedFacets
{
707 get { return decimalAllowedFacets; }
710 public override XmlTokenizedType TokenizedType
{
711 get { return XmlTokenizedType.None; }
715 public override XmlTypeCode TypeCode
{
716 get { return XmlTypeCode.Decimal; }
720 public override Type ValueType
{
721 get { return typeof (decimal); }
724 public override object ParseValue (string s
,
725 XmlNameTable nameTable
, NSResolver nsmgr
)
727 return ParseValueType (s
, nameTable
, nsmgr
);
730 internal override ValueType
ParseValueType (string s
, XmlNameTable nameTable
, NSResolver nsmgr
)
732 return XmlConvert
.ToDecimal (this.Normalize (s
));
735 internal override XsdOrdering
Compare(object x
, object y
) {
736 if ((x
is Decimal
) && (y
is Decimal
)) {
737 int ret
= Decimal
.Compare((Decimal
)x
, (Decimal
)y
);
739 return XsdOrdering
.LessThan
;
742 return XsdOrdering
.GreaterThan
;
745 return XsdOrdering
.Equal
;
748 return XsdOrdering
.Indeterminate
;
751 // Fundamental Facets
752 public override bool Bounded
{
753 get { return false; }
755 public override bool Finite
{
756 get { return false; }
758 public override bool Numeric
{
761 public override XsdOrderedFacet Ordered
{
762 get { return XsdOrderedFacet.Total; }
768 internal class XsdInteger
: XsdDecimal
775 public override XmlTypeCode TypeCode
{
776 get { return XmlTypeCode.Integer; }
780 // Here it may be bigger than int's (or long's) MaxValue.
781 public override Type ValueType
{
782 get { return typeof (decimal); }
785 public override object ParseValue (string s
,
786 XmlNameTable nameTable
, NSResolver nsmgr
)
788 return ParseValueType (s
, nameTable
, nsmgr
);
791 internal override ValueType
ParseValueType (string s
, XmlNameTable nameTable
, NSResolver nsmgr
)
793 decimal d
= XmlConvert
.ToDecimal (Normalize (s
));
794 if (Decimal
.Floor (d
) != d
)
795 throw new FormatException ("Integer contains point number.");
804 internal class XsdLong
: XsdInteger
807 public override XmlTypeCode TypeCode
{
808 get { return XmlTypeCode.Long; }
812 public override Type ValueType
{
813 get { return typeof (long); }
816 public override object ParseValue (string s
,
817 XmlNameTable nameTable
, NSResolver nsmgr
)
819 return ParseValueType (s
, nameTable
, nsmgr
);
822 internal override ValueType
ParseValueType (string s
, XmlNameTable nameTable
, NSResolver nsmgr
)
824 return XmlConvert
.ToInt64 (Normalize (s
));
827 internal override XsdOrdering
Compare(object x
, object y
) {
828 if ((x
is long) && (y
is long)) {
829 if ((long)x
==(long)y
) {
830 return XsdOrdering
.Equal
;
832 else if ((long)x
<(long)y
) {
833 return XsdOrdering
.LessThan
;
836 return XsdOrdering
.GreaterThan
;
839 return XsdOrdering
.Indeterminate
;
844 internal class XsdInt
: XsdLong
847 public override XmlTypeCode TypeCode
{
848 get { return XmlTypeCode.Int; }
852 public override Type ValueType
{
853 get { return typeof (int); }
856 public override object ParseValue (string s
,
857 XmlNameTable nameTable
, NSResolver nsmgr
)
859 return ParseValueType (s
, nameTable
, nsmgr
);
862 internal override ValueType
ParseValueType (string s
, XmlNameTable nameTable
, NSResolver nsmgr
)
864 return XmlConvert
.ToInt32 (Normalize (s
));
867 internal override XsdOrdering
Compare(object x
, object y
) {
868 if ((x
is int) && (y
is int)) {
869 if ((int)x
==(int)y
) {
870 return XsdOrdering
.Equal
;
872 else if ((int)x
<(int)y
) {
873 return XsdOrdering
.LessThan
;
876 return XsdOrdering
.GreaterThan
;
879 return XsdOrdering
.Indeterminate
;
885 internal class XsdShort
: XsdInt
888 public override XmlTypeCode TypeCode
{
889 get { return XmlTypeCode.Short; }
893 public override Type ValueType
{
894 get { return typeof (short); }
897 public override object ParseValue (string s
,
898 XmlNameTable nameTable
, NSResolver nsmgr
)
900 return ParseValueType (s
, nameTable
, nsmgr
);
903 internal override ValueType
ParseValueType (string s
, XmlNameTable nameTable
, NSResolver nsmgr
)
905 return XmlConvert
.ToInt16 (Normalize (s
));
908 internal override XsdOrdering
Compare(object x
, object y
) {
909 if ((x
is short) && (y
is short)) {
910 if ((short)x
==(short)y
) {
911 return XsdOrdering
.Equal
;
913 else if ((short)x
<(short)y
) {
914 return XsdOrdering
.LessThan
;
917 return XsdOrdering
.GreaterThan
;
920 return XsdOrdering
.Indeterminate
;
925 internal class XsdByte
: XsdShort
928 public override XmlTypeCode TypeCode
{
929 get { return XmlTypeCode.Byte; }
933 public override Type ValueType
{
934 get { return typeof (sbyte); }
937 public override object ParseValue (string s
,
938 XmlNameTable nameTable
, NSResolver nsmgr
)
940 return ParseValueType (s
, nameTable
, nsmgr
);
943 internal override ValueType
ParseValueType (string s
, XmlNameTable nameTable
, NSResolver nsmgr
)
945 return XmlConvert
.ToSByte (Normalize (s
));
948 internal override XsdOrdering
Compare(object x
, object y
) {
949 if ((x
is sbyte) && (y
is sbyte)) {
950 if ((sbyte)x
==(sbyte)y
) {
951 return XsdOrdering
.Equal
;
953 else if ((sbyte)x
<(sbyte)y
) {
954 return XsdOrdering
.LessThan
;
957 return XsdOrdering
.GreaterThan
;
960 return XsdOrdering
.Indeterminate
;
964 // xs:nonNegativeInteger
965 // [CLSCompliant (false)]
966 internal class XsdNonNegativeInteger
: XsdInteger
969 public override XmlTypeCode TypeCode
{
970 get { return XmlTypeCode.NonNegativeInteger; }
974 public override Type ValueType
{
975 get { return typeof (decimal); }
978 // [CLSCompliant (false)]
979 public override object ParseValue (string s
,
980 XmlNameTable nameTable
, NSResolver nsmgr
)
982 return ParseValueType (s
, nameTable
, nsmgr
);
985 internal override ValueType
ParseValueType (string s
, XmlNameTable nameTable
, NSResolver nsmgr
)
987 return XmlConvert
.ToDecimal (Normalize (s
));
992 // [CLSCompliant (false)]
993 internal class XsdUnsignedLong
: XsdNonNegativeInteger
996 public override XmlTypeCode TypeCode
{
997 get { return XmlTypeCode.UnsignedLong; }
1001 public override Type ValueType
{
1002 get { return typeof (ulong); }
1005 public override object ParseValue (string s
,
1006 XmlNameTable nameTable
, NSResolver nsmgr
)
1008 return ParseValueType (s
, nameTable
, nsmgr
);
1011 internal override ValueType
ParseValueType (string s
, XmlNameTable nameTable
, NSResolver nsmgr
)
1013 return XmlConvert
.ToUInt64 (Normalize (s
));
1016 internal override XsdOrdering
Compare(object x
, object y
) {
1017 if ((x
is ulong) && (y
is ulong)) {
1018 if ((ulong)x
==(ulong)y
) {
1019 return XsdOrdering
.Equal
;
1021 else if ((ulong)x
<(ulong)y
) {
1022 return XsdOrdering
.LessThan
;
1025 return XsdOrdering
.GreaterThan
;
1028 return XsdOrdering
.Indeterminate
;
1033 // [CLSCompliant (false)]
1034 internal class XsdUnsignedInt
: XsdUnsignedLong
1037 public override XmlTypeCode TypeCode
{
1038 get { return XmlTypeCode.UnsignedInt; }
1042 public override Type ValueType
{
1043 get { return typeof (uint); }
1046 public override object ParseValue (string s
,
1047 XmlNameTable nameTable
, NSResolver nsmgr
)
1049 return ParseValueType (s
, nameTable
, nsmgr
);
1052 internal override ValueType
ParseValueType (string s
, XmlNameTable nameTable
, NSResolver nsmgr
)
1054 return XmlConvert
.ToUInt32 (Normalize (s
));
1057 internal override XsdOrdering
Compare(object x
, object y
) {
1058 if ((x
is uint) && (y
is uint)) {
1059 if ((uint)x
==(uint)y
) {
1060 return XsdOrdering
.Equal
;
1062 else if ((uint)x
<(uint)y
) {
1063 return XsdOrdering
.LessThan
;
1066 return XsdOrdering
.GreaterThan
;
1069 return XsdOrdering
.Indeterminate
;
1075 // [CLSCompliant (false)]
1076 internal class XsdUnsignedShort
: XsdUnsignedInt
1079 public override XmlTypeCode TypeCode
{
1080 get { return XmlTypeCode.UnsignedShort; }
1084 public override Type ValueType
{
1085 get { return typeof (ushort); }
1088 public override object ParseValue (string s
,
1089 XmlNameTable nameTable
, NSResolver nsmgr
)
1091 return ParseValueType (s
, nameTable
, nsmgr
);
1094 internal override ValueType
ParseValueType (string s
, XmlNameTable nameTable
, NSResolver nsmgr
)
1096 return XmlConvert
.ToUInt16 (Normalize (s
));
1099 internal override XsdOrdering
Compare(object x
, object y
) {
1100 if ((x
is ushort) && (y
is ushort)) {
1101 if ((ushort)x
==(ushort)y
) {
1102 return XsdOrdering
.Equal
;
1104 else if ((ushort)x
<(ushort)y
) {
1105 return XsdOrdering
.LessThan
;
1108 return XsdOrdering
.GreaterThan
;
1111 return XsdOrdering
.Indeterminate
;
1116 // [CLSCompliant (false)]
1117 internal class XsdUnsignedByte
: XsdUnsignedShort
1120 public override XmlTypeCode TypeCode
{
1121 get { return XmlTypeCode.UnsignedByte; }
1125 public override Type ValueType
{
1126 get { return typeof (byte); }
1129 public override object ParseValue (string s
,
1130 XmlNameTable nameTable
, NSResolver nsmgr
)
1132 return ParseValueType (s
, nameTable
, nsmgr
);
1135 internal override ValueType
ParseValueType (string s
, XmlNameTable nameTable
, NSResolver nsmgr
)
1137 return XmlConvert
.ToByte(Normalize (s
));
1140 internal override XsdOrdering
Compare(object x
, object y
) {
1141 if ((x
is byte) && (y
is byte)) {
1142 if ((byte)x
==(byte)y
) {
1143 return XsdOrdering
.Equal
;
1145 else if ((byte)x
<(byte)y
) {
1146 return XsdOrdering
.LessThan
;
1149 return XsdOrdering
.GreaterThan
;
1152 return XsdOrdering
.Indeterminate
;
1157 // xs:positiveInteger
1158 // [CLSCompliant (false)]
1159 internal class XsdPositiveInteger
: XsdNonNegativeInteger
1162 public override XmlTypeCode TypeCode
{
1163 get { return XmlTypeCode.PositiveInteger; }
1167 // It returns decimal, instead of int or long.
1168 // Maybe MS developers thought about big integer...
1169 public override Type ValueType
{
1170 get { return typeof (decimal); }
1173 public override object ParseValue (string s
,
1174 XmlNameTable nameTable
, NSResolver nsmgr
)
1176 return ParseValueType (s
, nameTable
, nsmgr
);
1179 internal override ValueType
ParseValueType (string s
, XmlNameTable nameTable
, NSResolver nsmgr
)
1181 return XmlConvert
.ToDecimal (Normalize (s
));
1185 // xs:nonPositiveInteger
1186 internal class XsdNonPositiveInteger
: XsdInteger
1189 public override XmlTypeCode TypeCode
{
1190 get { return XmlTypeCode.NonPositiveInteger; }
1194 public override Type ValueType
{
1195 get { return typeof (decimal); }
1198 public override object ParseValue (string s
,
1199 XmlNameTable nameTable
, NSResolver nsmgr
)
1201 return ParseValueType (s
, nameTable
, nsmgr
);
1204 internal override ValueType
ParseValueType (string s
, XmlNameTable nameTable
, NSResolver nsmgr
)
1206 return XmlConvert
.ToDecimal (Normalize (s
));
1210 // xs:negativeInteger
1211 internal class XsdNegativeInteger
: XsdNonPositiveInteger
1214 public override XmlTypeCode TypeCode
{
1215 get { return XmlTypeCode.NegativeInteger; }
1219 public override Type ValueType
{
1221 get { return typeof (decimal); }
1224 public override object ParseValue (string s
,
1225 XmlNameTable nameTable
, NSResolver nsmgr
)
1227 return ParseValueType (s
, nameTable
, nsmgr
);
1230 internal override ValueType
ParseValueType (string s
, XmlNameTable nameTable
, NSResolver nsmgr
)
1232 return XmlConvert
.ToDecimal (Normalize (s
));
1237 internal class XsdFloat
: XsdAnySimpleType
1240 public override XmlTypeCode TypeCode
{
1241 get { return XmlTypeCode.Float; }
1245 internal XsdFloat ()
1247 this.WhitespaceValue
= XsdWhitespaceFacet
.Collapse
;
1250 internal override XmlSchemaFacet
.Facet AllowedFacets
{
1251 get { return durationAllowedFacets; }
1254 // Fundamental Facets
1255 public override bool Bounded
{
1256 get { return true; }
1258 public override bool Finite
{
1259 get { return true; }
1261 public override bool Numeric
{
1262 get { return true; }
1264 public override XsdOrderedFacet Ordered
{
1265 get { return XsdOrderedFacet.Total; }
1268 public override Type ValueType
{
1269 get { return typeof (float); }
1272 public override object ParseValue (string s
,
1273 XmlNameTable nameTable
, NSResolver nsmgr
)
1275 return ParseValueType (s
, nameTable
, nsmgr
);
1278 internal override ValueType
ParseValueType (string s
, XmlNameTable nameTable
, NSResolver nsmgr
)
1280 return XmlConvert
.ToSingle (Normalize (s
));
1283 internal override XsdOrdering
Compare(object x
, object y
) {
1284 if ((x
is float) && (y
is float)) {
1285 if ((float)x
==(float)y
) {
1286 return XsdOrdering
.Equal
;
1288 else if ((float)x
<(float)y
) {
1289 return XsdOrdering
.LessThan
;
1292 return XsdOrdering
.GreaterThan
;
1295 return XsdOrdering
.Indeterminate
;
1301 internal class XsdDouble
: XsdAnySimpleType
1303 internal XsdDouble ()
1305 this.WhitespaceValue
= XsdWhitespaceFacet
.Collapse
;
1308 internal override XmlSchemaFacet
.Facet AllowedFacets
{
1309 get { return durationAllowedFacets; }
1312 // Fundamental Facets
1313 public override bool Bounded
{
1314 get { return true; }
1316 public override bool Finite
{
1317 get { return true; }
1319 public override bool Numeric
{
1320 get { return true; }
1322 public override XsdOrderedFacet Ordered
{
1323 get { return XsdOrderedFacet.Total; }
1327 public override XmlTypeCode TypeCode
{
1328 get { return XmlTypeCode.Double; }
1332 public override Type ValueType
{
1333 get { return typeof (double); }
1336 public override object ParseValue (string s
,
1337 XmlNameTable nameTable
, NSResolver nsmgr
)
1339 return ParseValueType (s
, nameTable
, nsmgr
);
1342 internal override ValueType
ParseValueType (string s
, XmlNameTable nameTable
, NSResolver nsmgr
)
1344 return XmlConvert
.ToDouble (Normalize (s
));
1347 internal override XsdOrdering
Compare(object x
, object y
) {
1348 if ((x
is double) && (y
is double)) {
1349 if ((double)x
==(double)y
) {
1350 return XsdOrdering
.Equal
;
1352 else if ((double)x
<(double)y
) {
1353 return XsdOrdering
.LessThan
;
1356 return XsdOrdering
.GreaterThan
;
1359 return XsdOrdering
.Indeterminate
;
1365 internal class XsdBase64Binary
: XsdString
1367 internal XsdBase64Binary ()
1372 public override XmlTypeCode TypeCode
{
1373 get { return XmlTypeCode.Base64Binary; }
1377 public override Type ValueType
{
1378 get { return typeof (byte[]); }
1381 public override object ParseValue (string s
,
1382 XmlNameTable nameTable
, NSResolver nsmgr
)
1384 // If it isnt ASCII it isnt valid base64 data
1385 byte[] inArr
= new System
.Text
.ASCIIEncoding().GetBytes(s
);
1386 FromBase64Transform t
= new FromBase64Transform();
1387 return t
.TransformFinalBlock(inArr
, 0, inArr
.Length
);
1391 internal override int Length(string s
) {
1395 for (int i
= 0; i
< end
; i
++) {
1397 if (!Char
.IsWhiteSpace(c
)) {
1403 return -1; // Invalid characters
1407 return -1; // Max 2 padding at the end.
1411 return ((length
/4)*3)+pad
;
1414 /* TODO: Use the Base64Table and similar code when it makes it
1415 * out of System.Security.Cryptography (currently internal so I
1416 * don't think we can use it).
1419 private static string ALPHABET
=
1420 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
1422 private static byte[] decodeTable
;
1423 static XsdBase64Binary ()
1425 int len
= ALPHABET
.Length
;
1427 decodeTable
= new byte [1 + (int)'z'];
1429 for (int i
=0; i
< decodeTable
.Length
; i
++) {
1430 decodeTable
[i
] = Byte
.MaxValue
;
1433 for (int i
=0; i
< len
; i
++) {
1434 char ch
= ALPHABET
[i
];
1435 decodeTable
[(int)ch
] = (byte) i
;
1439 protected static bool isPad(char octect
) {
1440 return (octect
== '=');
1443 protected static bool isData(char octect
) {
1444 return ((octect
<= 'z') && (decodeTable
[octect
] != Byte
.MaxValue
));
1448 internal override ValueType
ParseValueType (string s
, XmlNameTable nameTable
, NSResolver nsmgr
)
1450 return new StringValueType (ParseValue (s
, nameTable
, nsmgr
) as string);
1456 internal class XsdHexBinary
: XsdAnySimpleType
1458 internal XsdHexBinary ()
1460 this.WhitespaceValue
= XsdWhitespaceFacet
.Collapse
;
1463 internal override XmlSchemaFacet
.Facet AllowedFacets
{
1464 get { return stringAllowedFacets; }
1468 public override XmlTypeCode TypeCode
{
1469 get { return XmlTypeCode.HexBinary; }
1473 public override XmlTokenizedType TokenizedType
{
1474 get { return XmlTokenizedType.None; }
1477 public override Type ValueType
{
1478 get { return typeof (byte []); }
1481 public override object ParseValue (string s
,
1482 XmlNameTable nameTable
, NSResolver nsmgr
)
1484 return XmlConvert
.FromBinHexString (Normalize (s
));
1487 internal override int Length(string s
) {
1488 return s
.Length
/ 2 + s
.Length
% 2 ; // Not sure if odd lengths are even allowed
1491 internal override ValueType
ParseValueType (string s
, XmlNameTable nameTable
, NSResolver nsmgr
)
1493 return new StringValueType (ParseValue (s
, nameTable
, nsmgr
) as string);
1496 // Fundamental Facets ... no need to override
1500 internal class XsdQName
: XsdName
1502 internal XsdQName ()
1506 // Fundamental facets are the same as anySimpleType.
1508 public override XmlTokenizedType TokenizedType
{
1509 get { return XmlTokenizedType.QName; }
1513 public override XmlTypeCode TypeCode
{
1514 get { return XmlTypeCode.QName; }
1518 public override Type ValueType
{
1519 get { return typeof (XmlQualifiedName); }
1522 // ParseValue () method is as same as that of xs:string
1523 public override object ParseValue (string s
,
1524 XmlNameTable nameTable
, NSResolver nsmgr
)
1526 if (nameTable
== null)
1527 throw new ArgumentNullException ("name table");
1529 throw new ArgumentNullException ("namespace manager");
1530 XmlQualifiedName name
= XmlQualifiedName
.Parse (s
, nsmgr
);
1531 nameTable
.Add (name
.Name
);
1532 nameTable
.Add (name
.Namespace
);
1536 internal override ValueType
ParseValueType (string s
, XmlNameTable nameTable
, NSResolver nsmgr
)
1538 return new QNameValueType (ParseValue (s
, nameTable
, nsmgr
) as XmlQualifiedName
);
1543 internal class XsdBoolean
: XsdAnySimpleType
1545 internal XsdBoolean ()
1547 this.WhitespaceValue
= XsdWhitespaceFacet
.Collapse
;
1550 internal override XmlSchemaFacet
.Facet AllowedFacets
{
1551 get { return booleanAllowedFacets; }
1554 public override XmlTokenizedType TokenizedType
{
1555 #if BUGGY_MS_COMPLIANT
1556 get { return XmlTokenizedType.None; }
1558 get { return XmlTokenizedType.CDATA; }
1563 public override XmlTypeCode TypeCode
{
1564 get { return XmlTypeCode.Boolean; }
1568 public override Type ValueType
{
1569 get { return typeof (bool); }
1572 public override object ParseValue (string s
,
1573 XmlNameTable nameTable
, NSResolver nsmgr
)
1575 return ParseValueType (s
, nameTable
, nsmgr
);
1578 internal override ValueType
ParseValueType (string s
, XmlNameTable nameTable
, NSResolver nsmgr
)
1580 return XmlConvert
.ToBoolean (this.Normalize (s
));
1583 // Fundamental Facets
1584 public override bool Bounded
{
1585 get { return false; }
1587 public override bool Finite
{
1588 get { return true; }
1590 public override bool Numeric
{
1591 get { return false; }
1593 public override XsdOrderedFacet Ordered
{
1594 get { return XsdOrderedFacet.Total; }
1601 internal class XsdAnyURI
: XsdString
1603 public override XmlTokenizedType TokenizedType
{
1605 get { return XmlTokenizedType.CDATA; }
1609 public override XmlTypeCode TypeCode
{
1610 get { return XmlTypeCode.AnyUri; }
1614 public override Type ValueType
{
1615 get { return typeof (Uri); }
1618 public override object ParseValue (string s
,
1619 XmlNameTable nameTable
, NSResolver nsmgr
)
1621 return new XmlSchemaUri (Normalize (s
));
1624 internal override ValueType
ParseValueType (string s
, XmlNameTable nameTable
, NSResolver nsmgr
)
1626 return new UriValueType ((XmlSchemaUri
) ParseValue (s
, nameTable
, nsmgr
));
1630 internal class XmlSchemaUri
: Uri
1632 public string value;
1634 // LAMESPEC: In this way, some strings that contain ':' might
1635 // result in exception (MS.NET looks implemented as such).
1636 public XmlSchemaUri (string src
)
1637 : this (src
, src
.IndexOf (':') > 0)
1641 private XmlSchemaUri (string src
, bool formal
)
1642 : base (formal
? src
: "anyuri:" + src
, !formal
)
1647 public static bool operator == (XmlSchemaUri v1
, XmlSchemaUri v2
)
1649 return v1
.value == v2
.value;
1652 public static bool operator != (XmlSchemaUri v1
, XmlSchemaUri v2
)
1654 return v1
.value != v2
.value;
1657 public override bool Equals (object obj
)
1659 if (obj
is XmlSchemaUri
)
1660 return (XmlSchemaUri
) obj
== this;
1665 public override int GetHashCode ()
1667 return value.GetHashCode ();
1670 public override string ToString ()
1677 internal class XsdDuration
: XsdAnySimpleType
1679 internal XsdDuration ()
1681 this.WhitespaceValue
= XsdWhitespaceFacet
.Collapse
;
1684 internal override XmlSchemaFacet
.Facet AllowedFacets
{
1685 get { return durationAllowedFacets; }
1688 public override XmlTokenizedType TokenizedType
{
1689 get { return XmlTokenizedType.CDATA; }
1693 public override XmlTypeCode TypeCode
{
1694 get { return XmlTypeCode.Duration; }
1698 public override Type ValueType
{
1699 get { return typeof (TimeSpan); }
1702 public override object ParseValue (string s
,
1703 XmlNameTable nameTable
, NSResolver nsmgr
)
1705 return ParseValueType (s
, nameTable
, nsmgr
);
1708 internal override ValueType
ParseValueType (string s
, XmlNameTable nameTable
, NSResolver nsmgr
)
1710 return XmlConvert
.ToTimeSpan (Normalize (s
));
1713 internal override XsdOrdering
Compare(object x
, object y
) {
1714 /* FIXME: This is really simple so far
1716 * In fact in order to do this correctly in XmlSchema, we cannot use TimeSpan as the base type
1717 * Though it turns out that MS .NET is a little broken in this regard too. Not doing comparisons
1720 if ((x
is TimeSpan
) && (y
is TimeSpan
)) {
1721 int ret
= TimeSpan
.Compare((TimeSpan
)x
, (TimeSpan
)y
);
1723 return XsdOrdering
.LessThan
;
1726 return XsdOrdering
.GreaterThan
;
1729 return XsdOrdering
.Equal
;
1732 return XsdOrdering
.Indeterminate
;
1736 // Fundamental Facets
1737 public override bool Bounded
{
1738 get { return false; }
1740 public override bool Finite
{
1741 get { return false; }
1743 public override bool Numeric
{
1744 get { return false; }
1746 public override XsdOrderedFacet Ordered
{
1747 get { return XsdOrderedFacet.Partial; }
1753 // xdt:dayTimeDuration
1754 internal class XdtDayTimeDuration
: XsdDuration
1756 internal XdtDayTimeDuration ()
1760 public override XmlTypeCode TypeCode
{
1761 get { return XmlTypeCode.DayTimeDuration; }
1764 public override Type ValueType
{
1765 get { return typeof (TimeSpan); }
1768 public override object ParseValue (string s
,
1769 XmlNameTable nameTable
, NSResolver nsmgr
)
1771 return ParseValueType (s
, nameTable
, nsmgr
);
1774 internal override ValueType
ParseValueType (string s
, XmlNameTable nameTable
, NSResolver nsmgr
)
1776 return XmlConvert
.ToTimeSpan (Normalize (s
));
1779 // FIXME: Fundamental Facets
1780 public override bool Bounded
{
1781 get { return false; }
1783 public override bool Finite
{
1784 get { return false; }
1786 public override bool Numeric
{
1787 get { return false; }
1789 public override XsdOrderedFacet Ordered
{
1790 get { return XsdOrderedFacet.Partial; }
1795 // xdt:yearMonthDuration
1796 internal class XdtYearMonthDuration
: XsdDuration
1798 internal XdtYearMonthDuration ()
1802 public override XmlTypeCode TypeCode
{
1803 get { return XmlTypeCode.YearMonthDuration; }
1806 public override Type ValueType
{
1807 get { return typeof (TimeSpan); }
1810 public override object ParseValue (string s
,
1811 XmlNameTable nameTable
, NSResolver nsmgr
)
1813 return ParseValueType (s
, nameTable
, nsmgr
);
1816 internal override ValueType
ParseValueType (string s
, XmlNameTable nameTable
, NSResolver nsmgr
)
1818 return XmlConvert
.ToTimeSpan (Normalize (s
));
1821 // FIXME: Fundamental Facets
1822 public override bool Bounded
{
1823 get { return false; }
1825 public override bool Finite
{
1826 get { return false; }
1828 public override bool Numeric
{
1829 get { return false; }
1831 public override XsdOrderedFacet Ordered
{
1832 get { return XsdOrderedFacet.Partial; }
1839 internal class XsdDateTime
: XsdAnySimpleType
1841 internal XsdDateTime ()
1843 this.WhitespaceValue
= XsdWhitespaceFacet
.Collapse
;
1846 internal override XmlSchemaFacet
.Facet AllowedFacets
{
1847 get { return durationAllowedFacets; }
1850 public override XmlTokenizedType TokenizedType
{
1851 get { return XmlTokenizedType.CDATA; }
1855 public override XmlTypeCode TypeCode
{
1856 get { return XmlTypeCode.DateTime; }
1860 public override Type ValueType
{
1861 get { return typeof (DateTime); }
1864 public override object ParseValue (string s
,
1865 XmlNameTable nameTable
, NSResolver nsmgr
)
1867 return ParseValueType (s
, nameTable
, nsmgr
);
1870 internal override ValueType
ParseValueType (string s
, XmlNameTable nameTable
, NSResolver nsmgr
)
1872 return XmlConvert
.ToDateTime (Normalize (s
));
1875 internal override XsdOrdering
Compare(object x
, object y
) {
1876 /* Really simple so far */
1877 if ((x
is DateTime
) && (y
is DateTime
)) {
1878 int ret
= DateTime
.Compare((DateTime
)x
, (DateTime
)y
);
1880 return XsdOrdering
.LessThan
;
1883 return XsdOrdering
.GreaterThan
;
1886 return XsdOrdering
.Equal
;
1889 return XsdOrdering
.Indeterminate
;
1892 // Fundamental Facets
1893 public override bool Bounded
{
1894 get { return false; }
1896 public override bool Finite
{
1897 get { return false; }
1899 public override bool Numeric
{
1900 get { return false; }
1902 public override XsdOrderedFacet Ordered
{
1903 get { return XsdOrderedFacet.Partial; }
1909 internal class XsdDate
: XsdAnySimpleType
1913 this.WhitespaceValue
= XsdWhitespaceFacet
.Collapse
;
1916 internal override XmlSchemaFacet
.Facet AllowedFacets
{
1917 get { return durationAllowedFacets; }
1920 public override XmlTokenizedType TokenizedType
{
1921 get { return XmlTokenizedType.CDATA; }
1925 public override XmlTypeCode TypeCode
{
1926 get { return XmlTypeCode.Date; }
1930 public override Type ValueType
{
1931 get { return typeof (DateTime); }
1934 public override object ParseValue (string s
,
1935 XmlNameTable nameTable
, NSResolver nsmgr
)
1937 return ParseValueType (s
, nameTable
, nsmgr
);
1940 internal override ValueType
ParseValueType (string s
, XmlNameTable nameTable
, NSResolver nsmgr
)
1942 return DateTime
.ParseExact (Normalize (s
), "yyyy-MM-dd", null);
1945 internal override XsdOrdering
Compare(object x
, object y
) {
1946 /* Really simple so far */
1947 if ((x
is DateTime
) && (y
is DateTime
)) {
1948 int ret
= DateTime
.Compare((DateTime
)x
, (DateTime
)y
);
1950 return XsdOrdering
.LessThan
;
1953 return XsdOrdering
.GreaterThan
;
1956 return XsdOrdering
.Equal
;
1959 return XsdOrdering
.Indeterminate
;
1961 // Fundamental Facets ... no need to override except for Ordered.
1962 public override XsdOrderedFacet Ordered
{
1963 get { return XsdOrderedFacet.Partial; }
1969 internal class XsdTime
: XsdAnySimpleType
1971 static string [] timeFormats
= new string [] {
1972 // copied from XmlConvert.
1986 "HH:mm:ss.fffffzzz",
1987 "HH:mm:ss.ffffffzzz",
1988 "HH:mm:ss.fffffffzzz",
1996 "HH:mm:ss.fffffffZ"};
2000 this.WhitespaceValue
= XsdWhitespaceFacet
.Collapse
;
2003 internal override XmlSchemaFacet
.Facet AllowedFacets
{
2004 get { return durationAllowedFacets; }
2007 public override XmlTokenizedType TokenizedType
{
2008 get { return XmlTokenizedType.CDATA; }
2012 public override XmlTypeCode TypeCode
{
2013 get { return XmlTypeCode.Time; }
2017 public override Type ValueType
{
2018 get { return typeof (DateTime); }
2021 public override object ParseValue (string s
,
2022 XmlNameTable nameTable
, NSResolver nsmgr
)
2024 return ParseValueType (s
, nameTable
, nsmgr
);
2027 internal override ValueType
ParseValueType (string s
, XmlNameTable nameTable
, NSResolver nsmgr
)
2029 return DateTime
.ParseExact (Normalize (s
), timeFormats
, null, DateTimeStyles
.None
);
2032 internal override XsdOrdering
Compare(object x
, object y
) {
2033 /* Really simple so far */
2034 if ((x
is DateTime
) && (y
is DateTime
)) {
2035 int ret
= DateTime
.Compare((DateTime
)x
, (DateTime
)y
);
2037 return XsdOrdering
.LessThan
;
2040 return XsdOrdering
.GreaterThan
;
2043 return XsdOrdering
.Equal
;
2046 return XsdOrdering
.Indeterminate
;
2048 // Fundamental Facets ... no need to override except for Ordered.
2049 public override XsdOrderedFacet Ordered
{
2050 get { return XsdOrderedFacet.Partial; }
2056 internal class XsdGYearMonth
: XsdAnySimpleType
2058 internal XsdGYearMonth ()
2060 this.WhitespaceValue
= XsdWhitespaceFacet
.Collapse
;
2063 internal override XmlSchemaFacet
.Facet AllowedFacets
{
2064 get { return durationAllowedFacets; }
2068 public override XmlTypeCode TypeCode
{
2069 get { return XmlTypeCode.GYearMonth; }
2073 public override Type ValueType
{
2074 get { return typeof (DateTime); }
2077 public override object ParseValue (string s
,
2078 XmlNameTable nameTable
, NSResolver nsmgr
)
2080 return ParseValueType (s
, nameTable
, nsmgr
);
2083 internal override ValueType
ParseValueType (string s
, XmlNameTable nameTable
, NSResolver nsmgr
)
2085 return DateTime
.ParseExact (Normalize (s
), "yyyy-MM", null);
2088 internal override XsdOrdering
Compare(object x
, object y
) {
2089 /* Really simple so far */
2090 if ((x
is DateTime
) && (y
is DateTime
)) {
2091 int ret
= DateTime
.Compare((DateTime
)x
, (DateTime
)y
);
2093 return XsdOrdering
.LessThan
;
2096 return XsdOrdering
.GreaterThan
;
2099 return XsdOrdering
.Equal
;
2102 return XsdOrdering
.Indeterminate
;
2107 internal class XsdGMonthDay
: XsdAnySimpleType
2109 internal XsdGMonthDay ()
2111 this.WhitespaceValue
= XsdWhitespaceFacet
.Collapse
;
2114 internal override XmlSchemaFacet
.Facet AllowedFacets
{
2115 get { return durationAllowedFacets; }
2119 public override XmlTypeCode TypeCode
{
2120 get { return XmlTypeCode.GMonthDay; }
2124 public override Type ValueType
{
2125 get { return typeof (DateTime); }
2128 public override object ParseValue (string s
,
2129 XmlNameTable nameTable
, NSResolver nsmgr
)
2131 return ParseValueType (s
, nameTable
, nsmgr
);
2134 internal override ValueType
ParseValueType (string s
, XmlNameTable nameTable
, NSResolver nsmgr
)
2136 return DateTime
.ParseExact (Normalize (s
), "--MM-dd", null);
2139 internal override XsdOrdering
Compare(object x
, object y
) {
2140 /* Really simple so far */
2141 if ((x
is DateTime
) && (y
is DateTime
)) {
2142 int ret
= DateTime
.Compare((DateTime
)x
, (DateTime
)y
);
2144 return XsdOrdering
.LessThan
;
2147 return XsdOrdering
.GreaterThan
;
2150 return XsdOrdering
.Equal
;
2153 return XsdOrdering
.Indeterminate
;
2158 internal class XsdGYear
: XsdAnySimpleType
2160 internal XsdGYear ()
2162 this.WhitespaceValue
= XsdWhitespaceFacet
.Collapse
;
2165 internal override XmlSchemaFacet
.Facet AllowedFacets
{
2166 get { return durationAllowedFacets; }
2170 public override XmlTypeCode TypeCode
{
2171 get { return XmlTypeCode.GYear; }
2175 public override Type ValueType
{
2176 get { return typeof (DateTime); }
2179 // LAMESPEC: XML Schema Datatypes allows leading '-' to identify B.C. years,
2180 // but CLR DateTime does not allow such expression.
2181 public override object ParseValue (string s
,
2182 XmlNameTable nameTable
, NSResolver nsmgr
)
2184 return ParseValueType (s
, nameTable
, nsmgr
);
2187 internal override ValueType
ParseValueType (string s
, XmlNameTable nameTable
, NSResolver nsmgr
)
2189 return DateTime
.ParseExact (Normalize(s
), "yyyy", null);
2192 internal override XsdOrdering
Compare(object x
, object y
) {
2193 /* Really simple so far */
2194 if ((x
is DateTime
) && (y
is DateTime
)) {
2195 int ret
= DateTime
.Compare((DateTime
)x
, (DateTime
)y
);
2197 return XsdOrdering
.LessThan
;
2200 return XsdOrdering
.GreaterThan
;
2203 return XsdOrdering
.Equal
;
2206 return XsdOrdering
.Indeterminate
;
2211 internal class XsdGMonth
: XsdAnySimpleType
2213 internal XsdGMonth ()
2215 this.WhitespaceValue
= XsdWhitespaceFacet
.Collapse
;
2218 internal override XmlSchemaFacet
.Facet AllowedFacets
{
2219 get { return durationAllowedFacets; }
2223 public override XmlTypeCode TypeCode
{
2224 get { return XmlTypeCode.GMonth; }
2228 public override Type ValueType
{
2229 get { return typeof (DateTime); }
2232 public override object ParseValue (string s
,
2233 XmlNameTable nameTable
, NSResolver nsmgr
)
2235 return ParseValueType (s
, nameTable
, nsmgr
);
2238 internal override ValueType
ParseValueType (string s
, XmlNameTable nameTable
, NSResolver nsmgr
)
2240 return DateTime
.ParseExact (Normalize(s
), "--MM--", null);
2243 internal override XsdOrdering
Compare(object x
, object y
) {
2244 /* Really simple so far */
2245 if ((x
is DateTime
) && (y
is DateTime
)) {
2246 int ret
= DateTime
.Compare((DateTime
)x
, (DateTime
)y
);
2248 return XsdOrdering
.LessThan
;
2251 return XsdOrdering
.GreaterThan
;
2254 return XsdOrdering
.Equal
;
2257 return XsdOrdering
.Indeterminate
;
2262 internal class XsdGDay
: XsdAnySimpleType
2266 this.WhitespaceValue
= XsdWhitespaceFacet
.Collapse
;
2269 internal override XmlSchemaFacet
.Facet AllowedFacets
{
2270 get { return durationAllowedFacets; }
2274 public override XmlTypeCode TypeCode
{
2275 get { return XmlTypeCode.GDay; }
2279 public override Type ValueType
{
2280 get { return typeof (DateTime); }
2283 public override object ParseValue (string s
,
2284 XmlNameTable nameTable
, NSResolver nsmgr
)
2286 return ParseValueType (s
, nameTable
, nsmgr
);
2289 internal override ValueType
ParseValueType (string s
, XmlNameTable nameTable
, NSResolver nsmgr
)
2291 return DateTime
.ParseExact (Normalize(s
), "---dd", null);
2294 internal override XsdOrdering
Compare(object x
, object y
) {
2295 /* Really simple so far */
2296 if ((x
is DateTime
) && (y
is DateTime
)) {
2297 int ret
= DateTime
.Compare((DateTime
)x
, (DateTime
)y
);
2299 return XsdOrdering
.LessThan
;
2302 return XsdOrdering
.GreaterThan
;
2305 return XsdOrdering
.Equal
;
2308 return XsdOrdering
.Indeterminate
;