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 static bool HasValidScheme (string src)
1636 int idx = src.IndexOf (':');
1639 for (int i = 0; i < idx; i++) {
1646 if (Char.IsLetterOrDigit (src [i]))
1654 // MS BUG: Some strings that contain ':' might result in
1655 // exception (MS.NET looks implemented as such).
1656 public XmlSchemaUri (string src)
1657 : this (src, HasValidScheme (src))
1661 private XmlSchemaUri (string src, bool formal)
1662 : base (formal ? src : "anyuri:" + src, !formal)
1667 public static bool operator == (XmlSchemaUri v1, XmlSchemaUri v2)
1669 return v1.value == v2.value;
1672 public static bool operator != (XmlSchemaUri v1, XmlSchemaUri v2)
1674 return v1.value != v2.value;
1677 public override bool Equals (object obj)
1679 if (obj is XmlSchemaUri)
1680 return (XmlSchemaUri) obj == this;
1685 public override int GetHashCode ()
1687 return value.GetHashCode ();
1690 public override string ToString ()
1697 internal class XsdDuration : XsdAnySimpleType
1699 internal XsdDuration ()
1701 this.WhitespaceValue = XsdWhitespaceFacet.Collapse;
1704 internal override XmlSchemaFacet.Facet AllowedFacets {
1705 get { return durationAllowedFacets; }
1708 public override XmlTokenizedType TokenizedType {
1709 get { return XmlTokenizedType.CDATA; }
1713 public override XmlTypeCode TypeCode {
1714 get { return XmlTypeCode.Duration; }
1718 public override Type ValueType {
1719 get { return typeof (TimeSpan); }
1722 public override object ParseValue (string s,
1723 XmlNameTable nameTable, NSResolver nsmgr)
1725 return ParseValueType (s, nameTable, nsmgr);
1728 internal override ValueType ParseValueType (string s, XmlNameTable nameTable, NSResolver nsmgr)
1730 return XmlConvert.ToTimeSpan (Normalize (s));
1733 internal override XsdOrdering Compare(object x, object y) {
1734 /* FIXME: This is really simple so far
1736 * In fact in order to do this correctly in XmlSchema, we cannot use TimeSpan as the base type
1737 * Though it turns out that MS .NET is a little broken in this regard too. Not doing comparisons
1740 if ((x is TimeSpan) && (y is TimeSpan)) {
1741 int ret = TimeSpan.Compare((TimeSpan)x, (TimeSpan)y);
1743 return XsdOrdering.LessThan;
1746 return XsdOrdering.GreaterThan;
1749 return XsdOrdering.Equal;
1752 return XsdOrdering.Indeterminate;
1756 // Fundamental Facets
1757 public override bool Bounded {
1758 get { return false; }
1760 public override bool Finite {
1761 get { return false; }
1763 public override bool Numeric {
1764 get { return false; }
1766 public override XsdOrderedFacet Ordered {
1767 get { return XsdOrderedFacet.Partial; }
1773 // xdt:dayTimeDuration
1774 internal class XdtDayTimeDuration : XsdDuration
1776 internal XdtDayTimeDuration ()
1780 public override XmlTypeCode TypeCode {
1781 get { return XmlTypeCode.DayTimeDuration; }
1784 public override Type ValueType {
1785 get { return typeof (TimeSpan); }
1788 public override object ParseValue (string s,
1789 XmlNameTable nameTable, NSResolver nsmgr)
1791 return ParseValueType (s, nameTable, nsmgr);
1794 internal override ValueType ParseValueType (string s, XmlNameTable nameTable, NSResolver nsmgr)
1796 return XmlConvert.ToTimeSpan (Normalize (s));
1799 // FIXME: Fundamental Facets
1800 public override bool Bounded {
1801 get { return false; }
1803 public override bool Finite {
1804 get { return false; }
1806 public override bool Numeric {
1807 get { return false; }
1809 public override XsdOrderedFacet Ordered {
1810 get { return XsdOrderedFacet.Partial; }
1815 // xdt:yearMonthDuration
1816 internal class XdtYearMonthDuration : XsdDuration
1818 internal XdtYearMonthDuration ()
1822 public override XmlTypeCode TypeCode {
1823 get { return XmlTypeCode.YearMonthDuration; }
1826 public override Type ValueType {
1827 get { return typeof (TimeSpan); }
1830 public override object ParseValue (string s,
1831 XmlNameTable nameTable, NSResolver nsmgr)
1833 return ParseValueType (s, nameTable, nsmgr);
1836 internal override ValueType ParseValueType (string s, XmlNameTable nameTable, NSResolver nsmgr)
1838 return XmlConvert.ToTimeSpan (Normalize (s));
1841 // FIXME: Fundamental Facets
1842 public override bool Bounded {
1843 get { return false; }
1845 public override bool Finite {
1846 get { return false; }
1848 public override bool Numeric {
1849 get { return false; }
1851 public override XsdOrderedFacet Ordered {
1852 get { return XsdOrderedFacet.Partial; }
1859 internal class XsdDateTime : XsdAnySimpleType
1861 internal XsdDateTime ()
1863 this.WhitespaceValue = XsdWhitespaceFacet.Collapse;
1866 internal override XmlSchemaFacet.Facet AllowedFacets {
1867 get { return durationAllowedFacets; }
1870 public override XmlTokenizedType TokenizedType {
1871 get { return XmlTokenizedType.CDATA; }
1875 public override XmlTypeCode TypeCode {
1876 get { return XmlTypeCode.DateTime; }
1880 public override Type ValueType {
1881 get { return typeof (DateTime); }
1884 public override object ParseValue (string s,
1885 XmlNameTable nameTable, NSResolver nsmgr)
1887 return ParseValueType (s, nameTable, nsmgr);
1890 internal override ValueType ParseValueType (string s, XmlNameTable nameTable, NSResolver nsmgr)
1892 return XmlConvert.ToDateTime (Normalize (s));
1895 internal override XsdOrdering Compare(object x, object y) {
1896 /* Really simple so far */
1897 if ((x is DateTime) && (y is DateTime)) {
1898 int ret = DateTime.Compare((DateTime)x, (DateTime)y);
1900 return XsdOrdering.LessThan;
1903 return XsdOrdering.GreaterThan;
1906 return XsdOrdering.Equal;
1909 return XsdOrdering.Indeterminate;
1912 // Fundamental Facets
1913 public override bool Bounded {
1914 get { return false; }
1916 public override bool Finite {
1917 get { return false; }
1919 public override bool Numeric {
1920 get { return false; }
1922 public override XsdOrderedFacet Ordered {
1923 get { return XsdOrderedFacet.Partial; }
1929 internal class XsdDate : XsdAnySimpleType
1933 this.WhitespaceValue = XsdWhitespaceFacet.Collapse;
1936 internal override XmlSchemaFacet.Facet AllowedFacets {
1937 get { return durationAllowedFacets; }
1940 public override XmlTokenizedType TokenizedType {
1941 get { return XmlTokenizedType.CDATA; }
1945 public override XmlTypeCode TypeCode {
1946 get { return XmlTypeCode.Date; }
1950 public override Type ValueType {
1951 get { return typeof (DateTime); }
1954 public override object ParseValue (string s,
1955 XmlNameTable nameTable, NSResolver nsmgr)
1957 return ParseValueType (s, nameTable, nsmgr);
1960 internal override ValueType ParseValueType (string s, XmlNameTable nameTable, NSResolver nsmgr)
1962 return DateTime.ParseExact (Normalize (s), "yyyy-MM-dd", null);
1965 internal override XsdOrdering Compare(object x, object y) {
1966 /* Really simple so far */
1967 if ((x is DateTime) && (y is DateTime)) {
1968 int ret = DateTime.Compare((DateTime)x, (DateTime)y);
1970 return XsdOrdering.LessThan;
1973 return XsdOrdering.GreaterThan;
1976 return XsdOrdering.Equal;
1979 return XsdOrdering.Indeterminate;
1981 // Fundamental Facets ... no need to override except for Ordered.
1982 public override XsdOrderedFacet Ordered {
1983 get { return XsdOrderedFacet.Partial; }
1989 internal class XsdTime : XsdAnySimpleType
1991 static string [] timeFormats = new string [] {
1992 // copied from XmlConvert.
2006 "HH:mm:ss.fffffzzz",
2007 "HH:mm:ss.ffffffzzz",
2008 "HH:mm:ss.fffffffzzz",
2016 "HH:mm:ss.fffffffZ"};
2020 this.WhitespaceValue = XsdWhitespaceFacet.Collapse;
2023 internal override XmlSchemaFacet.Facet AllowedFacets {
2024 get { return durationAllowedFacets; }
2027 public override XmlTokenizedType TokenizedType {
2028 get { return XmlTokenizedType.CDATA; }
2032 public override XmlTypeCode TypeCode {
2033 get { return XmlTypeCode.Time; }
2037 public override Type ValueType {
2038 get { return typeof (DateTime); }
2041 public override object ParseValue (string s,
2042 XmlNameTable nameTable, NSResolver nsmgr)
2044 return ParseValueType (s, nameTable, nsmgr);
2047 internal override ValueType ParseValueType (string s, XmlNameTable nameTable, NSResolver nsmgr)
2049 return DateTime.ParseExact (Normalize (s), timeFormats, null, DateTimeStyles.None);
2052 internal override XsdOrdering Compare(object x, object y) {
2053 /* Really simple so far */
2054 if ((x is DateTime) && (y is DateTime)) {
2055 int ret = DateTime.Compare((DateTime)x, (DateTime)y);
2057 return XsdOrdering.LessThan;
2060 return XsdOrdering.GreaterThan;
2063 return XsdOrdering.Equal;
2066 return XsdOrdering.Indeterminate;
2068 // Fundamental Facets ... no need to override except for Ordered.
2069 public override XsdOrderedFacet Ordered {
2070 get { return XsdOrderedFacet.Partial; }
2076 internal class XsdGYearMonth : XsdAnySimpleType
2078 internal XsdGYearMonth ()
2080 this.WhitespaceValue = XsdWhitespaceFacet.Collapse;
2083 internal override XmlSchemaFacet.Facet AllowedFacets {
2084 get { return durationAllowedFacets; }
2088 public override XmlTypeCode TypeCode {
2089 get { return XmlTypeCode.GYearMonth; }
2093 public override Type ValueType {
2094 get { return typeof (DateTime); }
2097 public override object ParseValue (string s,
2098 XmlNameTable nameTable, NSResolver nsmgr)
2100 return ParseValueType (s, nameTable, nsmgr);
2103 internal override ValueType ParseValueType (string s, XmlNameTable nameTable, NSResolver nsmgr)
2105 return DateTime.ParseExact (Normalize (s), "yyyy-MM", null);
2108 internal override XsdOrdering Compare(object x, object y) {
2109 /* Really simple so far */
2110 if ((x is DateTime) && (y is DateTime)) {
2111 int ret = DateTime.Compare((DateTime)x, (DateTime)y);
2113 return XsdOrdering.LessThan;
2116 return XsdOrdering.GreaterThan;
2119 return XsdOrdering.Equal;
2122 return XsdOrdering.Indeterminate;
2127 internal class XsdGMonthDay : XsdAnySimpleType
2129 internal XsdGMonthDay ()
2131 this.WhitespaceValue = XsdWhitespaceFacet.Collapse;
2134 internal override XmlSchemaFacet.Facet AllowedFacets {
2135 get { return durationAllowedFacets; }
2139 public override XmlTypeCode TypeCode {
2140 get { return XmlTypeCode.GMonthDay; }
2144 public override Type ValueType {
2145 get { return typeof (DateTime); }
2148 public override object ParseValue (string s,
2149 XmlNameTable nameTable, NSResolver nsmgr)
2151 return ParseValueType (s, nameTable, nsmgr);
2154 internal override ValueType ParseValueType (string s, XmlNameTable nameTable, NSResolver nsmgr)
2156 return DateTime.ParseExact (Normalize (s), "--MM-dd", null);
2159 internal override XsdOrdering Compare(object x, object y) {
2160 /* Really simple so far */
2161 if ((x is DateTime) && (y is DateTime)) {
2162 int ret = DateTime.Compare((DateTime)x, (DateTime)y);
2164 return XsdOrdering.LessThan;
2167 return XsdOrdering.GreaterThan;
2170 return XsdOrdering.Equal;
2173 return XsdOrdering.Indeterminate;
2178 internal class XsdGYear : XsdAnySimpleType
2180 internal XsdGYear ()
2182 this.WhitespaceValue = XsdWhitespaceFacet.Collapse;
2185 internal override XmlSchemaFacet.Facet AllowedFacets {
2186 get { return durationAllowedFacets; }
2190 public override XmlTypeCode TypeCode {
2191 get { return XmlTypeCode.GYear; }
2195 public override Type ValueType {
2196 get { return typeof (DateTime); }
2199 // LAMESPEC: XML Schema Datatypes allows leading '-' to identify B.C. years,
2200 // but CLR DateTime does not allow such expression.
2201 public override object ParseValue (string s,
2202 XmlNameTable nameTable, NSResolver nsmgr)
2204 return ParseValueType (s, nameTable, nsmgr);
2207 internal override ValueType ParseValueType (string s, XmlNameTable nameTable, NSResolver nsmgr)
2209 return DateTime.ParseExact (Normalize(s), "yyyy", null);
2212 internal override XsdOrdering Compare(object x, object y) {
2213 /* Really simple so far */
2214 if ((x is DateTime) && (y is DateTime)) {
2215 int ret = DateTime.Compare((DateTime)x, (DateTime)y);
2217 return XsdOrdering.LessThan;
2220 return XsdOrdering.GreaterThan;
2223 return XsdOrdering.Equal;
2226 return XsdOrdering.Indeterminate;
2231 internal class XsdGMonth : XsdAnySimpleType
2233 internal XsdGMonth ()
2235 this.WhitespaceValue = XsdWhitespaceFacet.Collapse;
2238 internal override XmlSchemaFacet.Facet AllowedFacets {
2239 get { return durationAllowedFacets; }
2243 public override XmlTypeCode TypeCode {
2244 get { return XmlTypeCode.GMonth; }
2248 public override Type ValueType {
2249 get { return typeof (DateTime); }
2252 public override object ParseValue (string s,
2253 XmlNameTable nameTable, NSResolver nsmgr)
2255 return ParseValueType (s, nameTable, nsmgr);
2258 internal override ValueType ParseValueType (string s, XmlNameTable nameTable, NSResolver nsmgr)
2260 return DateTime.ParseExact (Normalize(s), "--MM--", null);
2263 internal override XsdOrdering Compare(object x, object y) {
2264 /* Really simple so far */
2265 if ((x is DateTime) && (y is DateTime)) {
2266 int ret = DateTime.Compare((DateTime)x, (DateTime)y);
2268 return XsdOrdering.LessThan;
2271 return XsdOrdering.GreaterThan;
2274 return XsdOrdering.Equal;
2277 return XsdOrdering.Indeterminate;
2282 internal class XsdGDay : XsdAnySimpleType
2286 this.WhitespaceValue = XsdWhitespaceFacet.Collapse;
2289 internal override XmlSchemaFacet.Facet AllowedFacets {
2290 get { return durationAllowedFacets; }
2294 public override XmlTypeCode TypeCode {
2295 get { return XmlTypeCode.GDay; }
2299 public override Type ValueType {
2300 get { return typeof (DateTime); }
2303 public override object ParseValue (string s,
2304 XmlNameTable nameTable, NSResolver nsmgr)
2306 return ParseValueType (s, nameTable, nsmgr);
2309 internal override ValueType ParseValueType (string s, XmlNameTable nameTable, NSResolver nsmgr)
2311 return DateTime.ParseExact (Normalize(s), "---dd", null);
2314 internal override XsdOrdering Compare(object x, object y) {
2315 /* Really simple so far */
2316 if ((x is DateTime) && (y is DateTime)) {
2317 int ret = DateTime.Compare((DateTime)x, (DateTime)y);
2319 return XsdOrdering.LessThan;
2322 return XsdOrdering.GreaterThan;
2325 return XsdOrdering.Equal;
2328 return XsdOrdering.Indeterminate;