2 // System.Xml.Schema.XmlSchemaDatatype.cs
\r
7 // (C)2003 Atsushi Enomoto
\r
10 using System.Collections;
\r
13 using System.Xml.Schema;
\r
14 using System.Globalization;
\r
15 using System.Security.Cryptography;
\r
17 namespace Mono.Xml.Schema
\r
19 public enum XsdWhitespaceFacet
\r
26 public enum XsdOrderedFacet
\r
33 public enum XsdOrdering
\r
41 public class XsdAnySimpleType : XmlSchemaDatatype
\r
43 static XsdAnySimpleType instance;
\r
44 static XsdAnySimpleType ()
\r
46 instance = new XsdAnySimpleType ();
\r
49 public static XsdAnySimpleType Instance {
\r
50 get { return instance; }
\r
53 readonly char [] whitespaceArray = new char [] {' '};
\r
55 // Fundamental Facets
\r
56 public virtual bool Bounded {
\r
57 get { return false; }
\r
60 public virtual bool Finite {
\r
61 get { return false; }
\r
64 public virtual bool Numeric {
\r
65 get { return false; }
\r
68 public virtual XsdOrderedFacet Ordered {
\r
69 get { return XsdOrderedFacet.False; }
\r
72 public override Type ValueType {
\r
73 #if BUGGY_MS_COMPLIANT
\r
74 get { return typeof (string); }
\r
76 get { return typeof (object); }
\r
80 public override XmlTokenizedType TokenizedType {
\r
82 return XmlTokenizedType.None;
\r
86 public override object ParseValue (string s,
\r
87 XmlNameTable nameTable, XmlNamespaceManager nsmgr)
\r
89 return Normalize (s);
\r
92 internal override ValueType ParseValueType (string s,
\r
93 XmlNameTable nameTable, XmlNamespaceManager nsmgr)
\r
95 return new StringValueType (Normalize (s));
\r
98 internal string [] ParseListValue (string s, XmlNameTable nameTable)
\r
100 return this.Normalize (s, XsdWhitespaceFacet.Collapse).Split (whitespaceArray);
\r
105 // Can you even use XsdAnySimpleType in a schema?
\r
106 // -> Yes. See E1-22 of http://www.w3.org/2001/05/xmlschema-errata#Errata1 (somewhat paranoid ;-)
\r
108 internal bool AllowsFacet(XmlSchemaFacet xsf) {
\r
109 return (AllowedFacets & xsf.ThisFacet)!=0;
\r
114 internal virtual XsdOrdering Compare(object x, object y) {
\r
115 return XsdOrdering.Indeterminate;
\r
118 internal virtual int Length(string s) {
\r
123 // anySimpleType allows any facet
\r
124 internal virtual XmlSchemaFacet.Facet AllowedFacets {
\r
125 get { return XmlSchemaFacet.AllFacets ;}
\r
128 /* Matches facets allowed on boolean type
\r
130 internal const XmlSchemaFacet.Facet booleanAllowedFacets =
\r
131 XmlSchemaFacet.Facet.pattern | XmlSchemaFacet.Facet.whiteSpace;
\r
133 /* Matches facets allowed on decimal type.
\r
135 internal const XmlSchemaFacet.Facet decimalAllowedFacets =
\r
136 XmlSchemaFacet.Facet.pattern | XmlSchemaFacet.Facet.enumeration |
\r
137 XmlSchemaFacet.Facet.whiteSpace | XmlSchemaFacet.Facet.maxInclusive |
\r
138 XmlSchemaFacet.Facet.minInclusive | XmlSchemaFacet.Facet.maxExclusive |
\r
139 XmlSchemaFacet.Facet.minExclusive | XmlSchemaFacet.Facet.fractionDigits |
\r
140 XmlSchemaFacet.Facet.totalDigits ;
\r
142 /* Matches facets allowed on float, double, duration, dateTime, time, date,
\r
143 * gYearMonth, gYear, gMonthDay, gMonth, and gDay types
\r
146 internal const XmlSchemaFacet.Facet durationAllowedFacets =
\r
147 XmlSchemaFacet.Facet.pattern | XmlSchemaFacet.Facet.enumeration |
\r
148 XmlSchemaFacet.Facet.whiteSpace | XmlSchemaFacet.Facet.maxInclusive |
\r
149 XmlSchemaFacet.Facet.minInclusive | XmlSchemaFacet.Facet.maxExclusive |
\r
150 XmlSchemaFacet.Facet.minExclusive ;
\r
152 /* Matches facet allowed on string, hexBinary, base64Binary,
\r
153 * anyURI, QName and NOTATION types
\r
155 * Also used on list types
\r
158 internal const XmlSchemaFacet.Facet stringAllowedFacets =
\r
159 XmlSchemaFacet.Facet.length | XmlSchemaFacet.Facet.minLength |
\r
160 XmlSchemaFacet.Facet.maxLength | XmlSchemaFacet.Facet.pattern |
\r
161 XmlSchemaFacet.Facet.enumeration | XmlSchemaFacet.Facet.whiteSpace;
\r
165 public class XsdString : XsdAnySimpleType
\r
167 internal XsdString ()
\r
171 internal override XmlSchemaFacet.Facet AllowedFacets {
\r
172 get { return stringAllowedFacets; }
\r
175 public override XmlTokenizedType TokenizedType {
\r
176 get { return XmlTokenizedType.CDATA; }
\r
179 public override Type ValueType {
\r
180 get { return typeof (string); }
\r
183 // Fundamental Facets
\r
184 public override bool Bounded {
\r
185 get { return false; }
\r
187 public override bool Finite {
\r
188 get { return false; }
\r
190 public override bool Numeric {
\r
191 get { return false; }
\r
193 public override XsdOrderedFacet Ordered {
\r
194 get { return XsdOrderedFacet.False; }
\r
199 // xs:normalizedString
\r
200 public class XsdNormalizedString : XsdString
\r
202 internal XsdNormalizedString ()
\r
204 this.WhitespaceValue = XsdWhitespaceFacet.Replace;
\r
207 public override XmlTokenizedType TokenizedType {
\r
209 get { return XmlTokenizedType.CDATA; }
\r
212 public override Type ValueType {
\r
213 get { return typeof (string); }
\r
216 // ParseValue () method is as same as that of xs:string
\r
220 public class XsdToken : XsdNormalizedString
\r
222 internal XsdToken ()
\r
224 this.WhitespaceValue = XsdWhitespaceFacet.Collapse;
\r
227 public override XmlTokenizedType TokenizedType {
\r
228 get { return XmlTokenizedType.CDATA; }
\r
231 public override Type ValueType {
\r
232 get { return typeof (string); }
\r
235 // ParseValue () method is as same as that of xs:string
\r
239 public class XsdLanguage : XsdToken
\r
241 internal XsdLanguage ()
\r
245 public override XmlTokenizedType TokenizedType {
\r
246 get { return XmlTokenizedType.CDATA; }
\r
249 public override Type ValueType {
\r
250 get { return typeof (string); }
\r
253 // ParseValue () method is as same as that of xs:string
\r
257 public class XsdNMToken : XsdToken
\r
259 internal XsdNMToken ()
\r
263 public override XmlTokenizedType TokenizedType {
\r
264 get { return XmlTokenizedType.NMTOKEN; }
\r
267 public override Type ValueType {
\r
268 get { return typeof (string); }
\r
271 public override object ParseValue (string s,
\r
272 XmlNameTable nameTable, XmlNamespaceManager nsmgr)
\r
274 if (!XmlChar.IsNmToken (s))
\r
275 throw new ArgumentException ("'" + s + "' is an invalid NMTOKEN.");
\r
279 internal override ValueType ParseValueType (string s, XmlNameTable nameTable, XmlNamespaceManager nsmgr)
\r
281 return new StringValueType (ParseValue (s, nameTable, nsmgr) as string);
\r
286 public class XsdNMTokens : XsdNMToken
\r
288 internal XsdNMTokens ()
\r
292 public override XmlTokenizedType TokenizedType {
\r
293 get { return XmlTokenizedType.NMTOKENS; }
\r
296 public override Type ValueType {
\r
297 get { return typeof (string []); }
\r
300 public override object ParseValue (string value, XmlNameTable nt, XmlNamespaceManager nsmgr)
\r
302 return GetValidatedArray (value, nt);
\r
305 internal override ValueType ParseValueType (string s, XmlNameTable nameTable, XmlNamespaceManager nsmgr)
\r
307 return new StringArrayValueType (GetValidatedArray (s, nameTable));
\r
310 private string [] GetValidatedArray (string value, XmlNameTable nt)
\r
312 string [] nmtokens = ParseListValue (value, nt);
\r
313 for (int i = 0; i < nmtokens.Length; i++)
\r
314 if (!XmlChar.IsNmToken (nmtokens [i]))
\r
315 throw new ArgumentException ("Invalid name token.");
\r
321 public class XsdName : XsdToken
\r
323 internal XsdName ()
\r
327 public override XmlTokenizedType TokenizedType {
\r
328 get { return XmlTokenizedType.CDATA; }
\r
331 public override Type ValueType {
\r
332 get { return typeof (string); }
\r
335 public override object ParseValue (string s,
\r
336 XmlNameTable nameTable, XmlNamespaceManager nsmgr)
\r
338 if (!XmlChar.IsName (s))
\r
339 throw new ArgumentException ("'" + s + "' is an invalid name.");
\r
343 internal override ValueType ParseValueType (string s, XmlNameTable nameTable, XmlNamespaceManager nsmgr)
\r
345 return new StringValueType (ParseValue (s, nameTable, nsmgr) as string);
\r
350 public class XsdNCName : XsdName
\r
352 internal XsdNCName ()
\r
356 public override XmlTokenizedType TokenizedType {
\r
357 get { return XmlTokenizedType.NCName; }
\r
360 public override Type ValueType {
\r
361 get { return typeof (string); }
\r
364 public override object ParseValue (string s,
\r
365 XmlNameTable nameTable, XmlNamespaceManager nsmgr)
\r
367 if (!XmlChar.IsNCName (s))
\r
368 throw new ArgumentException ("'" + s + "' is an invalid NCName.");
\r
372 internal override ValueType ParseValueType (string s, XmlNameTable nameTable, XmlNamespaceManager nsmgr)
\r
374 return new StringValueType (ParseValue (s, nameTable, nsmgr) as string);
\r
379 public class XsdID : XsdName
\r
385 public override XmlTokenizedType TokenizedType {
\r
386 get { return XmlTokenizedType.ID; }
\r
389 public override Type ValueType {
\r
390 get { return typeof (string); }
\r
393 public override object ParseValue (string s, XmlNameTable nt, XmlNamespaceManager nsmgr)
\r
395 if (!XmlChar.IsNCName (s))
\r
396 throw new ArgumentException ("'" + s + "' is an invalid NCName.");
\r
402 public class XsdIDRef : XsdName
\r
404 internal XsdIDRef ()
\r
408 public override XmlTokenizedType TokenizedType {
\r
409 get { return XmlTokenizedType.IDREF; }
\r
412 public override Type ValueType {
\r
413 get { return typeof (string); }
\r
416 public override object ParseValue (string s, XmlNameTable nt, XmlNamespaceManager nsmgr)
\r
418 if (!XmlChar.IsNCName (s))
\r
419 throw new ArgumentException ("'" + s + "' is an invalid NCName.");
\r
425 public class XsdIDRefs : XsdName
\r
427 internal XsdIDRefs ()
\r
431 public override XmlTokenizedType TokenizedType {
\r
432 get { return XmlTokenizedType.IDREFS; }
\r
435 public override Type ValueType {
\r
436 get { return typeof (string []); }
\r
439 public override object ParseValue (string value, XmlNameTable nt, XmlNamespaceManager nsmgr)
\r
441 return GetValidatedArray (value, nt);
\r
444 internal override ValueType ParseValueType (string s, XmlNameTable nameTable, XmlNamespaceManager nsmgr)
\r
446 return new StringArrayValueType (GetValidatedArray (s, nameTable));
\r
449 private string [] GetValidatedArray (string value, XmlNameTable nt)
\r
451 string [] idrefs = ParseListValue (value, nt);
\r
452 for (int i = 0; i < idrefs.Length; i++)
\r
453 XmlConvert.VerifyNCName (idrefs [i]);
\r
459 public class XsdEntity : XsdName
\r
461 internal XsdEntity ()
\r
465 public override XmlTokenizedType TokenizedType {
\r
466 get { return XmlTokenizedType.ENTITY; }
\r
469 public override Type ValueType {
\r
470 get { return typeof (string); }
\r
478 public class XsdEntities : XsdName
\r
480 internal XsdEntities ()
\r
484 public override XmlTokenizedType TokenizedType {
\r
485 get { return XmlTokenizedType.ENTITIES; }
\r
488 public override Type ValueType {
\r
489 get { return typeof (string []); }
\r
492 public override object ParseValue (string value, XmlNameTable nt, XmlNamespaceManager nsmgr)
\r
494 return GetValidatedArray (value, nt);
\r
497 internal override ValueType ParseValueType (string s, XmlNameTable nameTable, XmlNamespaceManager nsmgr)
\r
499 return new StringArrayValueType (GetValidatedArray (s, nameTable));
\r
502 private string [] GetValidatedArray (string value, XmlNameTable nt)
\r
504 string [] entities = ParseListValue (value, nt);
\r
505 for (int i = 0; i < entities.Length; i++)
\r
506 if (!XmlChar.IsName (entities [i]))
\r
507 throw new ArgumentException ("Invalid entitiy name.");
\r
513 public class XsdNotation : XsdAnySimpleType
\r
515 internal XsdNotation ()
\r
519 internal override XmlSchemaFacet.Facet AllowedFacets {
\r
520 get { return stringAllowedFacets; }
\r
523 public override XmlTokenizedType TokenizedType {
\r
524 get { return XmlTokenizedType.NOTATION; }
\r
527 public override Type ValueType {
\r
528 get { return typeof (string); }
\r
531 public override object ParseValue (string s,
\r
532 XmlNameTable nameTable, XmlNamespaceManager nsmgr)
\r
534 return Normalize (s);
\r
537 // Fundamental Facets
\r
538 public override bool Bounded {
\r
539 get { return false; }
\r
541 public override bool Finite {
\r
542 get { return false; }
\r
544 public override bool Numeric {
\r
545 get { return false; }
\r
547 public override XsdOrderedFacet Ordered {
\r
548 get { return XsdOrderedFacet.False; }
\r
554 public class XsdDecimal : XsdAnySimpleType
\r
556 internal XsdDecimal ()
\r
558 this.WhitespaceValue = XsdWhitespaceFacet.Collapse;
\r
561 internal override XmlSchemaFacet.Facet AllowedFacets {
\r
562 get { return decimalAllowedFacets; }
\r
565 public override XmlTokenizedType TokenizedType {
\r
566 get { return XmlTokenizedType.None; }
\r
569 public override Type ValueType {
\r
570 get { return typeof (decimal); }
\r
573 public override object ParseValue (string s,
\r
574 XmlNameTable nameTable, XmlNamespaceManager nsmgr)
\r
576 return ParseValueType (s, nameTable, nsmgr);
\r
579 internal override ValueType ParseValueType (string s, XmlNameTable nameTable, XmlNamespaceManager nsmgr)
\r
581 return XmlConvert.ToDecimal (this.Normalize (s));
\r
584 internal override XsdOrdering Compare(object x, object y) {
\r
585 if ((x is Decimal) && (y is Decimal)) {
\r
586 int ret = Decimal.Compare((Decimal)x, (Decimal)y);
\r
588 return XsdOrdering.LessThan;
\r
590 else if (ret > 0) {
\r
591 return XsdOrdering.GreaterThan;
\r
594 return XsdOrdering.Equal;
\r
597 return XsdOrdering.Indeterminate;
\r
600 // Fundamental Facets
\r
601 public override bool Bounded {
\r
602 get { return false; }
\r
604 public override bool Finite {
\r
605 get { return false; }
\r
607 public override bool Numeric {
\r
608 get { return true; }
\r
610 public override XsdOrderedFacet Ordered {
\r
611 get { return XsdOrderedFacet.Total; }
\r
617 public class XsdInteger : XsdDecimal
\r
619 public XsdInteger ()
\r
623 // Here it may be bigger than int's (or long's) MaxValue.
\r
624 public override Type ValueType {
\r
625 get { return typeof (decimal); }
\r
628 public override object ParseValue (string s,
\r
629 XmlNameTable nameTable, XmlNamespaceManager nsmgr)
\r
631 return ParseValueType (s, nameTable, nsmgr);
\r
634 internal override ValueType ParseValueType (string s, XmlNameTable nameTable, XmlNamespaceManager nsmgr)
\r
636 decimal d = XmlConvert.ToDecimal (Normalize (s));
\r
637 if (Decimal.Floor (d) != d)
\r
638 throw new FormatException ("Integer contains point number.");
\r
647 public class XsdLong : XsdInteger
\r
649 public override Type ValueType {
\r
650 get { return typeof (long); }
\r
653 public override object ParseValue (string s,
\r
654 XmlNameTable nameTable, XmlNamespaceManager nsmgr)
\r
656 return ParseValueType (s, nameTable, nsmgr);
\r
659 internal override ValueType ParseValueType (string s, XmlNameTable nameTable, XmlNamespaceManager nsmgr)
\r
661 return XmlConvert.ToInt64 (Normalize (s));
\r
664 internal override XsdOrdering Compare(object x, object y) {
\r
665 if ((x is long) && (y is long)) {
\r
666 if ((long)x==(long)y) {
\r
667 return XsdOrdering.Equal;
\r
669 else if ((long)x<(long)y) {
\r
670 return XsdOrdering.LessThan;
\r
673 return XsdOrdering.GreaterThan;
\r
676 return XsdOrdering.Indeterminate;
\r
681 public class XsdInt : XsdLong
\r
683 public override Type ValueType {
\r
684 get { return typeof (int); }
\r
687 public override object ParseValue (string s,
\r
688 XmlNameTable nameTable, XmlNamespaceManager nsmgr)
\r
690 return ParseValueType (s, nameTable, nsmgr);
\r
693 internal override ValueType ParseValueType (string s, XmlNameTable nameTable, XmlNamespaceManager nsmgr)
\r
695 return XmlConvert.ToInt32 (Normalize (s));
\r
698 internal override XsdOrdering Compare(object x, object y) {
\r
699 if ((x is int) && (y is int)) {
\r
700 if ((int)x==(int)y) {
\r
701 return XsdOrdering.Equal;
\r
703 else if ((int)x<(int)y) {
\r
704 return XsdOrdering.LessThan;
\r
707 return XsdOrdering.GreaterThan;
\r
710 return XsdOrdering.Indeterminate;
\r
716 public class XsdShort : XsdInt
\r
718 public override Type ValueType {
\r
719 get { return typeof (short); }
\r
722 public override object ParseValue (string s,
\r
723 XmlNameTable nameTable, XmlNamespaceManager nsmgr)
\r
725 return ParseValueType (s, nameTable, nsmgr);
\r
728 internal override ValueType ParseValueType (string s, XmlNameTable nameTable, XmlNamespaceManager nsmgr)
\r
730 return XmlConvert.ToInt16 (Normalize (s));
\r
733 internal override XsdOrdering Compare(object x, object y) {
\r
734 if ((x is short) && (y is short)) {
\r
735 if ((short)x==(short)y) {
\r
736 return XsdOrdering.Equal;
\r
738 else if ((short)x<(short)y) {
\r
739 return XsdOrdering.LessThan;
\r
742 return XsdOrdering.GreaterThan;
\r
745 return XsdOrdering.Indeterminate;
\r
750 public class XsdByte : XsdShort
\r
752 public override Type ValueType {
\r
753 get { return typeof (sbyte); }
\r
756 public override object ParseValue (string s,
\r
757 XmlNameTable nameTable, XmlNamespaceManager nsmgr)
\r
759 return ParseValueType (s, nameTable, nsmgr);
\r
762 internal override ValueType ParseValueType (string s, XmlNameTable nameTable, XmlNamespaceManager nsmgr)
\r
764 return XmlConvert.ToSByte (Normalize (s));
\r
767 internal override XsdOrdering Compare(object x, object y) {
\r
768 if ((x is sbyte) && (y is sbyte)) {
\r
769 if ((sbyte)x==(sbyte)y) {
\r
770 return XsdOrdering.Equal;
\r
772 else if ((sbyte)x<(sbyte)y) {
\r
773 return XsdOrdering.LessThan;
\r
776 return XsdOrdering.GreaterThan;
\r
779 return XsdOrdering.Indeterminate;
\r
783 // xs:nonNegativeInteger
\r
784 [CLSCompliant (false)]
\r
785 public class XsdNonNegativeInteger : XsdInteger
\r
787 public override Type ValueType {
\r
788 get { return typeof (decimal); }
\r
791 [CLSCompliant (false)]
\r
792 public override object ParseValue (string s,
\r
793 XmlNameTable nameTable, XmlNamespaceManager nsmgr)
\r
795 return ParseValueType (s, nameTable, nsmgr);
\r
798 internal override ValueType ParseValueType (string s, XmlNameTable nameTable, XmlNamespaceManager nsmgr)
\r
800 return XmlConvert.ToDecimal (Normalize (s));
\r
805 [CLSCompliant (false)]
\r
806 public class XsdUnsignedLong : XsdNonNegativeInteger
\r
808 public override Type ValueType {
\r
809 get { return typeof (ulong); }
\r
812 public override object ParseValue (string s,
\r
813 XmlNameTable nameTable, XmlNamespaceManager nsmgr)
\r
815 return ParseValueType (s, nameTable, nsmgr);
\r
818 internal override ValueType ParseValueType (string s, XmlNameTable nameTable, XmlNamespaceManager nsmgr)
\r
820 return XmlConvert.ToUInt64 (Normalize (s));
\r
823 internal override XsdOrdering Compare(object x, object y) {
\r
824 if ((x is ulong) && (y is ulong)) {
\r
825 if ((ulong)x==(ulong)y) {
\r
826 return XsdOrdering.Equal;
\r
828 else if ((ulong)x<(ulong)y) {
\r
829 return XsdOrdering.LessThan;
\r
832 return XsdOrdering.GreaterThan;
\r
835 return XsdOrdering.Indeterminate;
\r
840 [CLSCompliant (false)]
\r
841 public class XsdUnsignedInt : XsdUnsignedLong
\r
843 public override Type ValueType {
\r
844 get { return typeof (uint); }
\r
847 public override object ParseValue (string s,
\r
848 XmlNameTable nameTable, XmlNamespaceManager nsmgr)
\r
850 return ParseValueType (s, nameTable, nsmgr);
\r
853 internal override ValueType ParseValueType (string s, XmlNameTable nameTable, XmlNamespaceManager nsmgr)
\r
855 return XmlConvert.ToUInt32 (Normalize (s));
\r
858 internal override XsdOrdering Compare(object x, object y) {
\r
859 if ((x is uint) && (y is uint)) {
\r
860 if ((uint)x==(uint)y) {
\r
861 return XsdOrdering.Equal;
\r
863 else if ((uint)x<(uint)y) {
\r
864 return XsdOrdering.LessThan;
\r
867 return XsdOrdering.GreaterThan;
\r
870 return XsdOrdering.Indeterminate;
\r
875 // xs:unsignedShort
\r
876 [CLSCompliant (false)]
\r
877 public class XsdUnsignedShort : XsdUnsignedInt
\r
879 public override Type ValueType {
\r
880 get { return typeof (ushort); }
\r
883 public override object ParseValue (string s,
\r
884 XmlNameTable nameTable, XmlNamespaceManager nsmgr)
\r
886 return ParseValueType (s, nameTable, nsmgr);
\r
889 internal override ValueType ParseValueType (string s, XmlNameTable nameTable, XmlNamespaceManager nsmgr)
\r
891 return XmlConvert.ToUInt16 (Normalize (s));
\r
894 internal override XsdOrdering Compare(object x, object y) {
\r
895 if ((x is ushort) && (y is ushort)) {
\r
896 if ((ushort)x==(ushort)y) {
\r
897 return XsdOrdering.Equal;
\r
899 else if ((ushort)x<(ushort)y) {
\r
900 return XsdOrdering.LessThan;
\r
903 return XsdOrdering.GreaterThan;
\r
906 return XsdOrdering.Indeterminate;
\r
911 [CLSCompliant (false)]
\r
912 public class XsdUnsignedByte : XsdUnsignedShort
\r
914 public override Type ValueType {
\r
915 get { return typeof (byte); }
\r
918 public override object ParseValue (string s,
\r
919 XmlNameTable nameTable, XmlNamespaceManager nsmgr)
\r
921 return ParseValueType (s, nameTable, nsmgr);
\r
924 internal override ValueType ParseValueType (string s, XmlNameTable nameTable, XmlNamespaceManager nsmgr)
\r
926 return XmlConvert.ToByte(Normalize (s));
\r
929 internal override XsdOrdering Compare(object x, object y) {
\r
930 if ((x is byte) && (y is byte)) {
\r
931 if ((byte)x==(byte)y) {
\r
932 return XsdOrdering.Equal;
\r
934 else if ((byte)x<(byte)y) {
\r
935 return XsdOrdering.LessThan;
\r
938 return XsdOrdering.GreaterThan;
\r
941 return XsdOrdering.Indeterminate;
\r
946 // xs:positiveInteger
\r
947 [CLSCompliant (false)]
\r
948 public class XsdPositiveInteger : XsdNonNegativeInteger
\r
950 // It returns decimal, instead of int or long.
\r
951 // Maybe MS developers thought about big integer...
\r
952 public override Type ValueType {
\r
953 get { return typeof (decimal); }
\r
956 public override object ParseValue (string s,
\r
957 XmlNameTable nameTable, XmlNamespaceManager nsmgr)
\r
959 return ParseValueType (s, nameTable, nsmgr);
\r
962 internal override ValueType ParseValueType (string s, XmlNameTable nameTable, XmlNamespaceManager nsmgr)
\r
964 return XmlConvert.ToDecimal (Normalize (s));
\r
968 // xs:nonPositiveInteger
\r
969 public class XsdNonPositiveInteger : XsdInteger
\r
971 public override Type ValueType {
\r
972 get { return typeof (decimal); }
\r
975 public override object ParseValue (string s,
\r
976 XmlNameTable nameTable, XmlNamespaceManager nsmgr)
\r
978 return ParseValueType (s, nameTable, nsmgr);
\r
981 internal override ValueType ParseValueType (string s, XmlNameTable nameTable, XmlNamespaceManager nsmgr)
\r
983 return XmlConvert.ToDecimal (Normalize (s));
\r
987 // xs:negativeInteger
\r
988 public class XsdNegativeInteger : XsdNonPositiveInteger
\r
990 public override Type ValueType {
\r
992 get { return typeof (decimal); }
\r
995 public override object ParseValue (string s,
\r
996 XmlNameTable nameTable, XmlNamespaceManager nsmgr)
\r
998 return ParseValueType (s, nameTable, nsmgr);
\r
1001 internal override ValueType ParseValueType (string s, XmlNameTable nameTable, XmlNamespaceManager nsmgr)
\r
1003 return XmlConvert.ToDecimal (Normalize (s));
\r
1008 public class XsdFloat : XsdAnySimpleType
\r
1010 internal XsdFloat ()
\r
1012 this.WhitespaceValue = XsdWhitespaceFacet.Collapse;
\r
1015 internal override XmlSchemaFacet.Facet AllowedFacets {
\r
1016 get { return durationAllowedFacets; }
\r
1019 // Fundamental Facets
\r
1020 public override bool Bounded {
\r
1021 get { return true; }
\r
1023 public override bool Finite {
\r
1024 get { return true; }
\r
1026 public override bool Numeric {
\r
1027 get { return true; }
\r
1029 public override XsdOrderedFacet Ordered {
\r
1030 get { return XsdOrderedFacet.Total; }
\r
1033 public override Type ValueType {
\r
1034 get { return typeof (float); }
\r
1037 public override object ParseValue (string s,
\r
1038 XmlNameTable nameTable, XmlNamespaceManager nsmgr)
\r
1040 return ParseValueType (s, nameTable, nsmgr);
\r
1043 internal override ValueType ParseValueType (string s, XmlNameTable nameTable, XmlNamespaceManager nsmgr)
\r
1045 return XmlConvert.ToSingle (Normalize (s));
\r
1048 internal override XsdOrdering Compare(object x, object y) {
\r
1049 if ((x is float) && (y is float)) {
\r
1050 if ((float)x==(float)y) {
\r
1051 return XsdOrdering.Equal;
\r
1053 else if ((float)x<(float)y) {
\r
1054 return XsdOrdering.LessThan;
\r
1057 return XsdOrdering.GreaterThan;
\r
1060 return XsdOrdering.Indeterminate;
\r
1066 public class XsdDouble : XsdAnySimpleType
\r
1068 internal XsdDouble ()
\r
1070 this.WhitespaceValue = XsdWhitespaceFacet.Collapse;
\r
1073 internal override XmlSchemaFacet.Facet AllowedFacets {
\r
1074 get { return durationAllowedFacets; }
\r
1077 // Fundamental Facets
\r
1078 public override bool Bounded {
\r
1079 get { return true; }
\r
1081 public override bool Finite {
\r
1082 get { return true; }
\r
1084 public override bool Numeric {
\r
1085 get { return true; }
\r
1087 public override XsdOrderedFacet Ordered {
\r
1088 get { return XsdOrderedFacet.Total; }
\r
1091 public override Type ValueType {
\r
1092 get { return typeof (double); }
\r
1095 public override object ParseValue (string s,
\r
1096 XmlNameTable nameTable, XmlNamespaceManager nsmgr)
\r
1098 return ParseValueType (s, nameTable, nsmgr);
\r
1101 internal override ValueType ParseValueType (string s, XmlNameTable nameTable, XmlNamespaceManager nsmgr)
\r
1103 return XmlConvert.ToDouble (Normalize (s));
\r
1106 internal override XsdOrdering Compare(object x, object y) {
\r
1107 if ((x is double) && (y is double)) {
\r
1108 if ((double)x==(double)y) {
\r
1109 return XsdOrdering.Equal;
\r
1111 else if ((double)x<(double)y) {
\r
1112 return XsdOrdering.LessThan;
\r
1115 return XsdOrdering.GreaterThan;
\r
1118 return XsdOrdering.Indeterminate;
\r
1123 // xs:base64Binary
\r
1124 public class XsdBase64Binary : XsdString
\r
1126 internal XsdBase64Binary ()
\r
1130 public override Type ValueType {
\r
1131 get { return typeof (byte[]); }
\r
1134 public override object ParseValue (string s,
\r
1135 XmlNameTable nameTable, XmlNamespaceManager nsmgr)
\r
1137 // If it isnt ASCII it isnt valid base64 data
\r
1138 byte[] inArr = new System.Text.ASCIIEncoding().GetBytes(s);
\r
1139 FromBase64Transform t = new FromBase64Transform();
\r
1140 return t.TransformFinalBlock(inArr, 0, inArr.Length);
\r
1144 internal override int Length(string s) {
\r
1147 int end = s.Length;
\r
1148 for (int i = 0; i < end; i++) {
\r
1150 if (!Char.IsWhiteSpace(c)) {
\r
1153 else if (isPad(c))
\r
1156 return -1; // Invalid characters
\r
1160 return -1; // Max 2 padding at the end.
\r
1164 return ((length/4)*3)+pad;
\r
1167 /* TODO: Use the Base64Table and similar code when it makes it
\r
1168 * out of System.Security.Cryptography (currently internal so I
\r
1169 * don't think we can use it).
\r
1172 private static string ALPHABET =
\r
1173 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
\r
1175 private static byte[] decodeTable;
\r
1176 static XsdBase64Binary ()
\r
1178 int len = ALPHABET.Length;
\r
1180 decodeTable = new byte [1 + (int)'z'];
\r
1182 for (int i=0; i < decodeTable.Length; i++) {
\r
1183 decodeTable [i] = Byte.MaxValue;
\r
1186 for (int i=0; i < len; i++) {
\r
1187 char ch = ALPHABET [i];
\r
1188 decodeTable [(int)ch] = (byte) i;
\r
1192 protected static bool isPad(char octect) {
\r
1193 return (octect == '=');
\r
1196 protected static bool isData(char octect) {
\r
1197 return ((octect <= 'z') && (decodeTable[octect] != Byte.MaxValue));
\r
1201 internal override ValueType ParseValueType (string s, XmlNameTable nameTable, XmlNamespaceManager nsmgr)
\r
1203 return new StringValueType (ParseValue (s, nameTable, nsmgr) as string);
\r
1209 public class XsdHexBinary : XsdAnySimpleType
\r
1211 internal XsdHexBinary ()
\r
1213 this.WhitespaceValue = XsdWhitespaceFacet.Collapse;
\r
1216 internal override XmlSchemaFacet.Facet AllowedFacets {
\r
1217 get { return stringAllowedFacets; }
\r
1220 public override XmlTokenizedType TokenizedType {
\r
1221 get { return XmlTokenizedType.None; }
\r
1224 public override Type ValueType {
\r
1225 get { return typeof (byte []); }
\r
1228 public override object ParseValue (string s,
\r
1229 XmlNameTable nameTable, XmlNamespaceManager nsmgr)
\r
1231 return XmlConvert.FromBinHexString (Normalize (s));
\r
1234 internal override int Length(string s) {
\r
1235 return s.Length / 2 + s.Length % 2 ; // Not sure if odd lengths are even allowed
\r
1238 internal override ValueType ParseValueType (string s, XmlNameTable nameTable, XmlNamespaceManager nsmgr)
\r
1240 return new StringValueType (ParseValue (s, nameTable, nsmgr) as string);
\r
1243 // Fundamental Facets ... no need to override
\r
1247 public class XsdQName : XsdName
\r
1249 internal XsdQName ()
\r
1253 // Fundamental facets are the same as anySimpleType.
\r
1255 public override XmlTokenizedType TokenizedType {
\r
1256 get { return XmlTokenizedType.QName; }
\r
1259 public override Type ValueType {
\r
1260 get { return typeof (XmlQualifiedName); }
\r
1263 // ParseValue () method is as same as that of xs:string
\r
1264 public override object ParseValue (string s,
\r
1265 XmlNameTable nameTable, XmlNamespaceManager nsmgr)
\r
1267 if (nameTable == null)
\r
1268 throw new ArgumentNullException ("name table");
\r
1269 if (nsmgr == null)
\r
1270 throw new ArgumentNullException ("namespace manager");
\r
1271 int colonAt = s.IndexOf (':');
\r
1272 string localName = colonAt < 0 ? s : s.Substring (colonAt + 1);
\r
1273 // string localName = nameTable.Add (colonAt < 0 ? s : s.Substring (colonAt + 1));
\r
1274 return new XmlQualifiedName (localName, nsmgr.LookupNamespace (
\r
1275 colonAt < 0 ? "" : s.Substring (0, colonAt - 1)));
\r
1278 internal override ValueType ParseValueType (string s, XmlNameTable nameTable, XmlNamespaceManager nsmgr)
\r
1280 return new QNameValueType (ParseValue (s, nameTable, nsmgr) as XmlQualifiedName);
\r
1285 public class XsdBoolean : XsdAnySimpleType
\r
1287 internal XsdBoolean ()
\r
1289 this.WhitespaceValue = XsdWhitespaceFacet.Collapse;
\r
1292 internal override XmlSchemaFacet.Facet AllowedFacets {
\r
1293 get { return booleanAllowedFacets; }
\r
1296 public override XmlTokenizedType TokenizedType {
\r
1297 #if BUGGY_MS_COMPLIANT
\r
1298 get { return XmlTokenizedType.None; }
\r
1300 get { return XmlTokenizedType.CDATA; }
\r
1304 public override Type ValueType {
\r
1305 get { return typeof (bool); }
\r
1308 public override object ParseValue (string s,
\r
1309 XmlNameTable nameTable, XmlNamespaceManager nsmgr)
\r
1311 return ParseValueType (s, nameTable, nsmgr);
\r
1314 internal override ValueType ParseValueType (string s, XmlNameTable nameTable, XmlNamespaceManager nsmgr)
\r
1316 return XmlConvert.ToBoolean (this.Normalize (s));
\r
1319 // Fundamental Facets
\r
1320 public override bool Bounded {
\r
1321 get { return false; }
\r
1323 public override bool Finite {
\r
1324 get { return true; }
\r
1326 public override bool Numeric {
\r
1327 get { return false; }
\r
1329 public override XsdOrderedFacet Ordered {
\r
1330 get { return XsdOrderedFacet.Total; }
\r
1337 public class XsdAnyURI : XsdString
\r
1339 public override XmlTokenizedType TokenizedType {
\r
1341 get { return XmlTokenizedType.CDATA; }
\r
1344 public override Type ValueType {
\r
1345 get { return typeof (Uri); }
\r
1348 public override object ParseValue (string s,
\r
1349 XmlNameTable nameTable, XmlNamespaceManager nsmgr)
\r
1351 return ParseValueType (s, nameTable, nsmgr);
\r
1354 internal override ValueType ParseValueType (string s, XmlNameTable nameTable, XmlNamespaceManager nsmgr)
\r
1356 return new UriValueType (Normalize (s));
\r
1361 public class XsdDuration : XsdAnySimpleType
\r
1363 internal XsdDuration ()
\r
1365 this.WhitespaceValue = XsdWhitespaceFacet.Collapse;
\r
1368 internal override XmlSchemaFacet.Facet AllowedFacets {
\r
1369 get { return durationAllowedFacets; }
\r
1372 public override XmlTokenizedType TokenizedType {
\r
1373 get { return XmlTokenizedType.CDATA; }
\r
1376 public override Type ValueType {
\r
1377 get { return typeof (TimeSpan); }
\r
1380 public override object ParseValue (string s,
\r
1381 XmlNameTable nameTable, XmlNamespaceManager nsmgr)
\r
1383 return ParseValueType (s, nameTable, nsmgr);
\r
1386 internal override ValueType ParseValueType (string s, XmlNameTable nameTable, XmlNamespaceManager nsmgr)
\r
1388 return XmlConvert.ToTimeSpan (Normalize (s));
\r
1391 internal override XsdOrdering Compare(object x, object y) {
\r
1392 /* FIXME: This is really simple so far
\r
1394 * In fact in order to do this correctly in XmlSchema, we cannot use TimeSpan as the base type
\r
1395 * Though it turns out that MS .NET is a little broken in this regard too. Not doing comparisons
\r
1398 if ((x is TimeSpan) && (y is TimeSpan)) {
\r
1399 int ret = TimeSpan.Compare((TimeSpan)x, (TimeSpan)y);
\r
1401 return XsdOrdering.LessThan;
\r
1403 else if (ret > 0) {
\r
1404 return XsdOrdering.GreaterThan;
\r
1407 return XsdOrdering.Equal;
\r
1410 return XsdOrdering.Indeterminate;
\r
1414 // Fundamental Facets
\r
1415 public override bool Bounded {
\r
1416 get { return false; }
\r
1418 public override bool Finite {
\r
1419 get { return false; }
\r
1421 public override bool Numeric {
\r
1422 get { return false; }
\r
1424 public override XsdOrderedFacet Ordered {
\r
1425 get { return XsdOrderedFacet.Partial; }
\r
1431 public class XsdDateTime : XsdAnySimpleType
\r
1433 internal XsdDateTime ()
\r
1435 this.WhitespaceValue = XsdWhitespaceFacet.Collapse;
\r
1438 internal override XmlSchemaFacet.Facet AllowedFacets {
\r
1439 get { return durationAllowedFacets; }
\r
1442 public override XmlTokenizedType TokenizedType {
\r
1443 get { return XmlTokenizedType.CDATA; }
\r
1446 public override Type ValueType {
\r
1447 get { return typeof (DateTime); }
\r
1450 public override object ParseValue (string s,
\r
1451 XmlNameTable nameTable, XmlNamespaceManager nsmgr)
\r
1453 return ParseValueType (s, nameTable, nsmgr);
\r
1456 internal override ValueType ParseValueType (string s, XmlNameTable nameTable, XmlNamespaceManager nsmgr)
\r
1458 return XmlConvert.ToDateTime (Normalize (s));
\r
1461 internal override XsdOrdering Compare(object x, object y) {
\r
1462 /* Really simple so far */
\r
1463 if ((x is DateTime) && (y is DateTime)) {
\r
1464 int ret = DateTime.Compare((DateTime)x, (DateTime)y);
\r
1466 return XsdOrdering.LessThan;
\r
1468 else if (ret > 0) {
\r
1469 return XsdOrdering.GreaterThan;
\r
1472 return XsdOrdering.Equal;
\r
1475 return XsdOrdering.Indeterminate;
\r
1478 // Fundamental Facets
\r
1479 public override bool Bounded {
\r
1480 get { return false; }
\r
1482 public override bool Finite {
\r
1483 get { return false; }
\r
1485 public override bool Numeric {
\r
1486 get { return false; }
\r
1488 public override XsdOrderedFacet Ordered {
\r
1489 get { return XsdOrderedFacet.Partial; }
\r
1495 public class XsdDate : XsdAnySimpleType
\r
1497 internal XsdDate ()
\r
1499 this.WhitespaceValue = XsdWhitespaceFacet.Collapse;
\r
1502 internal override XmlSchemaFacet.Facet AllowedFacets {
\r
1503 get { return durationAllowedFacets; }
\r
1506 public override XmlTokenizedType TokenizedType {
\r
1507 get { return XmlTokenizedType.CDATA; }
\r
1510 public override Type ValueType {
\r
1511 get { return typeof (DateTime); }
\r
1514 public override object ParseValue (string s,
\r
1515 XmlNameTable nameTable, XmlNamespaceManager nsmgr)
\r
1517 return ParseValueType (s, nameTable, nsmgr);
\r
1520 internal override ValueType ParseValueType (string s, XmlNameTable nameTable, XmlNamespaceManager nsmgr)
\r
1522 return DateTime.ParseExact (Normalize (s), "yyyy-MM-dd", null);
\r
1525 internal override XsdOrdering Compare(object x, object y) {
\r
1526 /* Really simple so far */
\r
1527 if ((x is DateTime) && (y is DateTime)) {
\r
1528 int ret = DateTime.Compare((DateTime)x, (DateTime)y);
\r
1530 return XsdOrdering.LessThan;
\r
1532 else if (ret > 0) {
\r
1533 return XsdOrdering.GreaterThan;
\r
1536 return XsdOrdering.Equal;
\r
1539 return XsdOrdering.Indeterminate;
\r
1541 // Fundamental Facets ... no need to override except for Ordered.
\r
1542 public override XsdOrderedFacet Ordered {
\r
1543 get { return XsdOrderedFacet.Partial; }
\r
1549 public class XsdTime : XsdAnySimpleType
\r
1551 static string [] timeFormats = new string [] {
\r
1552 // copied from XmlConvert.
\r
1559 "HH:mm:ss.ffffff",
\r
1560 "HH:mm:ss.fffffff",
\r
1564 "HH:mm:ss.fffzzz",
\r
1565 "HH:mm:ss.ffffzzz",
\r
1566 "HH:mm:ss.fffffzzz",
\r
1567 "HH:mm:ss.ffffffzzz",
\r
1568 "HH:mm:ss.fffffffzzz",
\r
1574 "HH:mm:ss.fffffZ",
\r
1575 "HH:mm:ss.ffffffZ",
\r
1576 "HH:mm:ss.fffffffZ"};
\r
1578 internal XsdTime ()
\r
1580 this.WhitespaceValue = XsdWhitespaceFacet.Collapse;
\r
1583 internal override XmlSchemaFacet.Facet AllowedFacets {
\r
1584 get { return durationAllowedFacets; }
\r
1587 public override XmlTokenizedType TokenizedType {
\r
1588 get { return XmlTokenizedType.CDATA; }
\r
1591 public override Type ValueType {
\r
1592 get { return typeof (DateTime); }
\r
1595 public override object ParseValue (string s,
\r
1596 XmlNameTable nameTable, XmlNamespaceManager nsmgr)
\r
1598 return ParseValueType (s, nameTable, nsmgr);
\r
1601 internal override ValueType ParseValueType (string s, XmlNameTable nameTable, XmlNamespaceManager nsmgr)
\r
1603 return DateTime.ParseExact (Normalize (s), timeFormats, null, DateTimeStyles.None);
\r
1606 internal override XsdOrdering Compare(object x, object y) {
\r
1607 /* Really simple so far */
\r
1608 if ((x is DateTime) && (y is DateTime)) {
\r
1609 int ret = DateTime.Compare((DateTime)x, (DateTime)y);
\r
1611 return XsdOrdering.LessThan;
\r
1613 else if (ret > 0) {
\r
1614 return XsdOrdering.GreaterThan;
\r
1617 return XsdOrdering.Equal;
\r
1620 return XsdOrdering.Indeterminate;
\r
1622 // Fundamental Facets ... no need to override except for Ordered.
\r
1623 public override XsdOrderedFacet Ordered {
\r
1624 get { return XsdOrderedFacet.Partial; }
\r
1630 public class XsdGYearMonth : XsdAnySimpleType
\r
1632 internal XsdGYearMonth ()
\r
1634 this.WhitespaceValue = XsdWhitespaceFacet.Collapse;
\r
1637 internal override XmlSchemaFacet.Facet AllowedFacets {
\r
1638 get { return durationAllowedFacets; }
\r
1641 public override Type ValueType {
\r
1642 get { return typeof (DateTime); }
\r
1645 public override object ParseValue (string s,
\r
1646 XmlNameTable nameTable, XmlNamespaceManager nsmgr)
\r
1648 return ParseValueType (s, nameTable, nsmgr);
\r
1651 internal override ValueType ParseValueType (string s, XmlNameTable nameTable, XmlNamespaceManager nsmgr)
\r
1653 return DateTime.ParseExact (Normalize (s), "yyyy-MM", null);
\r
1656 internal override XsdOrdering Compare(object x, object y) {
\r
1657 /* Really simple so far */
\r
1658 if ((x is DateTime) && (y is DateTime)) {
\r
1659 int ret = DateTime.Compare((DateTime)x, (DateTime)y);
\r
1661 return XsdOrdering.LessThan;
\r
1663 else if (ret > 0) {
\r
1664 return XsdOrdering.GreaterThan;
\r
1667 return XsdOrdering.Equal;
\r
1670 return XsdOrdering.Indeterminate;
\r
1675 public class XsdGMonthDay : XsdAnySimpleType
\r
1677 internal XsdGMonthDay ()
\r
1679 this.WhitespaceValue = XsdWhitespaceFacet.Collapse;
\r
1682 internal override XmlSchemaFacet.Facet AllowedFacets {
\r
1683 get { return durationAllowedFacets; }
\r
1686 public override Type ValueType {
\r
1687 get { return typeof (DateTime); }
\r
1690 public override object ParseValue (string s,
\r
1691 XmlNameTable nameTable, XmlNamespaceManager nsmgr)
\r
1693 return ParseValueType (s, nameTable, nsmgr);
\r
1696 internal override ValueType ParseValueType (string s, XmlNameTable nameTable, XmlNamespaceManager nsmgr)
\r
1698 return DateTime.ParseExact (Normalize (s), "--MM-dd", null);
\r
1701 internal override XsdOrdering Compare(object x, object y) {
\r
1702 /* Really simple so far */
\r
1703 if ((x is DateTime) && (y is DateTime)) {
\r
1704 int ret = DateTime.Compare((DateTime)x, (DateTime)y);
\r
1706 return XsdOrdering.LessThan;
\r
1708 else if (ret > 0) {
\r
1709 return XsdOrdering.GreaterThan;
\r
1712 return XsdOrdering.Equal;
\r
1715 return XsdOrdering.Indeterminate;
\r
1720 public class XsdGYear : XsdAnySimpleType
\r
1722 internal XsdGYear ()
\r
1724 this.WhitespaceValue = XsdWhitespaceFacet.Collapse;
\r
1727 internal override XmlSchemaFacet.Facet AllowedFacets {
\r
1728 get { return durationAllowedFacets; }
\r
1731 public override Type ValueType {
\r
1732 get { return typeof (DateTime); }
\r
1735 // LAMESPEC: XML Schema Datatypes allows leading '-' to identify B.C. years,
\r
1736 // but CLR DateTime does not allow such expression.
\r
1737 public override object ParseValue (string s,
\r
1738 XmlNameTable nameTable, XmlNamespaceManager nsmgr)
\r
1740 return ParseValueType (s, nameTable, nsmgr);
\r
1743 internal override ValueType ParseValueType (string s, XmlNameTable nameTable, XmlNamespaceManager nsmgr)
\r
1745 return DateTime.ParseExact (Normalize(s), "yyyy", null);
\r
1748 internal override XsdOrdering Compare(object x, object y) {
\r
1749 /* Really simple so far */
\r
1750 if ((x is DateTime) && (y is DateTime)) {
\r
1751 int ret = DateTime.Compare((DateTime)x, (DateTime)y);
\r
1753 return XsdOrdering.LessThan;
\r
1755 else if (ret > 0) {
\r
1756 return XsdOrdering.GreaterThan;
\r
1759 return XsdOrdering.Equal;
\r
1762 return XsdOrdering.Indeterminate;
\r
1767 public class XsdGMonth : XsdAnySimpleType
\r
1769 internal XsdGMonth ()
\r
1771 this.WhitespaceValue = XsdWhitespaceFacet.Collapse;
\r
1774 internal override XmlSchemaFacet.Facet AllowedFacets {
\r
1775 get { return durationAllowedFacets; }
\r
1778 public override Type ValueType {
\r
1779 get { return typeof (DateTime); }
\r
1782 public override object ParseValue (string s,
\r
1783 XmlNameTable nameTable, XmlNamespaceManager nsmgr)
\r
1785 return ParseValueType (s, nameTable, nsmgr);
\r
1788 internal override ValueType ParseValueType (string s, XmlNameTable nameTable, XmlNamespaceManager nsmgr)
\r
1790 return DateTime.ParseExact (Normalize(s), "--MM--", null);
\r
1793 internal override XsdOrdering Compare(object x, object y) {
\r
1794 /* Really simple so far */
\r
1795 if ((x is DateTime) && (y is DateTime)) {
\r
1796 int ret = DateTime.Compare((DateTime)x, (DateTime)y);
\r
1798 return XsdOrdering.LessThan;
\r
1800 else if (ret > 0) {
\r
1801 return XsdOrdering.GreaterThan;
\r
1804 return XsdOrdering.Equal;
\r
1807 return XsdOrdering.Indeterminate;
\r
1812 public class XsdGDay : XsdAnySimpleType
\r
1814 internal XsdGDay ()
\r
1816 this.WhitespaceValue = XsdWhitespaceFacet.Collapse;
\r
1819 internal override XmlSchemaFacet.Facet AllowedFacets {
\r
1820 get { return durationAllowedFacets; }
\r
1823 public override Type ValueType {
\r
1824 get { return typeof (DateTime); }
\r
1827 public override object ParseValue (string s,
\r
1828 XmlNameTable nameTable, XmlNamespaceManager nsmgr)
\r
1830 return ParseValueType (s, nameTable, nsmgr);
\r
1833 internal override ValueType ParseValueType (string s, XmlNameTable nameTable, XmlNamespaceManager nsmgr)
\r
1835 return DateTime.ParseExact (Normalize(s), "---dd", null);
\r
1838 internal override XsdOrdering Compare(object x, object y) {
\r
1839 /* Really simple so far */
\r
1840 if ((x is DateTime) && (y is DateTime)) {
\r
1841 int ret = DateTime.Compare((DateTime)x, (DateTime)y);
\r
1843 return XsdOrdering.LessThan;
\r
1845 else if (ret > 0) {
\r
1846 return XsdOrdering.GreaterThan;
\r
1849 return XsdOrdering.Equal;
\r
1852 return XsdOrdering.Indeterminate;
\r