2 // System.Xml.Schema.XmlSchemaDatatype.cs
\r
7 // (C)2003 Atsushi Enomoto
\r
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;
\r
34 using System.Xml.Schema;
\r
35 using System.Globalization;
\r
36 using System.Security.Cryptography;
\r
39 using NSResolver = System.Xml.IXmlNamespaceResolver;
\r
41 using NSResolver = System.Xml.XmlNamespaceManager;
\r
45 namespace Mono.Xml.Schema
\r
47 internal enum XsdWhitespaceFacet
\r
54 internal enum XsdOrderedFacet
\r
61 internal enum XsdOrdering
\r
69 internal class XsdAnySimpleType : XmlSchemaDatatype
\r
71 static XsdAnySimpleType instance;
\r
72 static XsdAnySimpleType ()
\r
74 instance = new XsdAnySimpleType ();
\r
77 public static XsdAnySimpleType Instance {
\r
78 get { return instance; }
\r
82 public override XmlTypeCode TypeCode {
\r
83 get { return XmlTypeCode.AnyAtomicType; }
\r
87 static readonly char [] whitespaceArray = new char [] {' '};
\r
89 // Fundamental Facets
\r
90 public virtual bool Bounded {
\r
91 get { return false; }
\r
94 public virtual bool Finite {
\r
95 get { return false; }
\r
98 public virtual bool Numeric {
\r
99 get { return false; }
\r
102 public virtual XsdOrderedFacet Ordered {
\r
103 get { return XsdOrderedFacet.False; }
\r
106 public override Type ValueType {
\r
107 #if BUGGY_MS_COMPLIANT
\r
108 get { return typeof (string); }
\r
110 get { return typeof (object); }
\r
114 public override XmlTokenizedType TokenizedType {
\r
116 return XmlTokenizedType.None;
\r
120 public override object ParseValue (string s,
\r
121 XmlNameTable nameTable, NSResolver nsmgr)
\r
123 return Normalize (s);
\r
126 internal override ValueType ParseValueType (string s,
\r
127 XmlNameTable nameTable, NSResolver nsmgr)
\r
129 return new StringValueType (Normalize (s));
\r
132 internal string [] ParseListValue (string s, XmlNameTable nameTable)
\r
134 return this.Normalize (s, XsdWhitespaceFacet.Collapse).Split (whitespaceArray);
\r
139 // Can you even use XsdAnySimpleType in a schema?
\r
140 // -> Yes. See E1-22 of http://www.w3.org/2001/05/xmlschema-errata#Errata1 (somewhat paranoid ;-)
\r
142 internal bool AllowsFacet(XmlSchemaFacet xsf) {
\r
143 return (AllowedFacets & xsf.ThisFacet)!=0;
\r
148 internal virtual XsdOrdering Compare(object x, object y) {
\r
149 return XsdOrdering.Indeterminate;
\r
152 internal virtual int Length(string s) {
\r
157 // anySimpleType allows any facet
\r
158 internal virtual XmlSchemaFacet.Facet AllowedFacets {
\r
159 get { return XmlSchemaFacet.AllFacets ;}
\r
162 /* Matches facets allowed on boolean type
\r
164 internal static readonly XmlSchemaFacet.Facet booleanAllowedFacets =
\r
165 XmlSchemaFacet.Facet.pattern | XmlSchemaFacet.Facet.whiteSpace;
\r
167 /* Matches facets allowed on decimal type.
\r
169 internal static readonly XmlSchemaFacet.Facet decimalAllowedFacets =
\r
170 XmlSchemaFacet.Facet.pattern | XmlSchemaFacet.Facet.enumeration |
\r
171 XmlSchemaFacet.Facet.whiteSpace | XmlSchemaFacet.Facet.maxInclusive |
\r
172 XmlSchemaFacet.Facet.minInclusive | XmlSchemaFacet.Facet.maxExclusive |
\r
173 XmlSchemaFacet.Facet.minExclusive | XmlSchemaFacet.Facet.fractionDigits |
\r
174 XmlSchemaFacet.Facet.totalDigits ;
\r
176 /* Matches facets allowed on float, double, duration, dateTime, time, date,
\r
177 * gYearMonth, gYear, gMonthDay, gMonth, and gDay types
\r
180 internal static readonly XmlSchemaFacet.Facet durationAllowedFacets =
\r
181 XmlSchemaFacet.Facet.pattern | XmlSchemaFacet.Facet.enumeration |
\r
182 XmlSchemaFacet.Facet.whiteSpace | XmlSchemaFacet.Facet.maxInclusive |
\r
183 XmlSchemaFacet.Facet.minInclusive | XmlSchemaFacet.Facet.maxExclusive |
\r
184 XmlSchemaFacet.Facet.minExclusive ;
\r
186 /* Matches facet allowed on string, hexBinary, base64Binary,
\r
187 * anyURI, QName and NOTATION types
\r
189 * Also used on list types
\r
192 internal static readonly XmlSchemaFacet.Facet stringAllowedFacets =
\r
193 XmlSchemaFacet.Facet.length | XmlSchemaFacet.Facet.minLength |
\r
194 XmlSchemaFacet.Facet.maxLength | XmlSchemaFacet.Facet.pattern |
\r
195 XmlSchemaFacet.Facet.enumeration | XmlSchemaFacet.Facet.whiteSpace;
\r
199 internal class XdtAnyAtomicType : XsdAnySimpleType
\r
201 internal XdtAnyAtomicType ()
\r
205 public override XmlTypeCode TypeCode {
\r
206 get { return XmlTypeCode.AnyAtomicType; }
\r
210 internal class XdtUntypedAtomic : XdtAnyAtomicType
\r
212 internal XdtUntypedAtomic ()
\r
216 public override XmlTypeCode TypeCode {
\r
217 get { return XmlTypeCode.UntypedAtomic; }
\r
223 internal class XsdString : XsdAnySimpleType
\r
225 internal XsdString ()
\r
229 internal override XmlSchemaFacet.Facet AllowedFacets {
\r
230 get { return stringAllowedFacets; }
\r
233 public override XmlTokenizedType TokenizedType {
\r
234 get { return XmlTokenizedType.CDATA; }
\r
238 public override XmlTypeCode TypeCode {
\r
239 get { return XmlTypeCode.String; }
\r
243 public override Type ValueType {
\r
244 get { return typeof (string); }
\r
247 // Fundamental Facets
\r
248 public override bool Bounded {
\r
249 get { return false; }
\r
251 public override bool Finite {
\r
252 get { return false; }
\r
254 public override bool Numeric {
\r
255 get { return false; }
\r
257 public override XsdOrderedFacet Ordered {
\r
258 get { return XsdOrderedFacet.False; }
\r
263 // xs:normalizedString
\r
264 internal class XsdNormalizedString : XsdString
\r
266 internal XsdNormalizedString ()
\r
268 this.WhitespaceValue = XsdWhitespaceFacet.Replace;
\r
271 public override XmlTokenizedType TokenizedType {
\r
273 get { return XmlTokenizedType.CDATA; }
\r
277 public override XmlTypeCode TypeCode {
\r
278 get { return XmlTypeCode.NormalizedString; }
\r
282 public override Type ValueType {
\r
283 get { return typeof (string); }
\r
286 // ParseValue () method is as same as that of xs:string
\r
290 internal class XsdToken : XsdNormalizedString
\r
292 internal XsdToken ()
\r
294 this.WhitespaceValue = XsdWhitespaceFacet.Collapse;
\r
297 public override XmlTokenizedType TokenizedType {
\r
298 get { return XmlTokenizedType.CDATA; }
\r
302 public override XmlTypeCode TypeCode {
\r
303 get { return XmlTypeCode.Token; }
\r
307 public override Type ValueType {
\r
308 get { return typeof (string); }
\r
311 // ParseValue () method is as same as that of xs:string
\r
315 internal class XsdLanguage : XsdToken
\r
317 internal XsdLanguage ()
\r
321 public override XmlTokenizedType TokenizedType {
\r
322 get { return XmlTokenizedType.CDATA; }
\r
326 public override XmlTypeCode TypeCode {
\r
327 get { return XmlTypeCode.Language; }
\r
331 public override Type ValueType {
\r
332 get { return typeof (string); }
\r
335 // ParseValue () method is as same as that of xs:string
\r
339 internal class XsdNMToken : XsdToken
\r
341 internal XsdNMToken ()
\r
345 public override XmlTokenizedType TokenizedType {
\r
346 get { return XmlTokenizedType.NMTOKEN; }
\r
350 public override XmlTypeCode TypeCode {
\r
351 get { return XmlTypeCode.NmToken; }
\r
355 public override Type ValueType {
\r
356 get { return typeof (string); }
\r
359 public override object ParseValue (string s,
\r
360 XmlNameTable nameTable, NSResolver nsmgr)
\r
362 if (!XmlChar.IsNmToken (s))
\r
363 throw new ArgumentException ("'" + s + "' is an invalid NMTOKEN.");
\r
367 internal override ValueType ParseValueType (string s, XmlNameTable nameTable, NSResolver nsmgr)
\r
369 return new StringValueType (ParseValue (s, nameTable, nsmgr) as string);
\r
374 internal class XsdNMTokens : XsdNMToken
\r
376 internal XsdNMTokens ()
\r
380 public override XmlTokenizedType TokenizedType {
\r
381 get { return XmlTokenizedType.NMTOKENS; }
\r
386 public override XmlTypeCode TypeCode {
\r
387 get { return XmlTypeCode.Item; }
\r
391 public override Type ValueType {
\r
392 get { return typeof (string []); }
\r
395 public override object ParseValue (string value, XmlNameTable nt, NSResolver nsmgr)
\r
397 return GetValidatedArray (value, nt);
\r
400 internal override ValueType ParseValueType (string s, XmlNameTable nameTable, NSResolver nsmgr)
\r
402 return new StringArrayValueType (GetValidatedArray (s, nameTable));
\r
405 private string [] GetValidatedArray (string value, XmlNameTable nt)
\r
407 string [] nmtokens = ParseListValue (value, nt);
\r
408 for (int i = 0; i < nmtokens.Length; i++)
\r
409 if (!XmlChar.IsNmToken (nmtokens [i]))
\r
410 throw new ArgumentException ("Invalid name token.");
\r
416 internal class XsdName : XsdToken
\r
418 internal XsdName ()
\r
422 public override XmlTokenizedType TokenizedType {
\r
423 get { return XmlTokenizedType.CDATA; }
\r
427 public override XmlTypeCode TypeCode {
\r
428 get { return XmlTypeCode.Name; }
\r
432 public override Type ValueType {
\r
433 get { return typeof (string); }
\r
436 public override object ParseValue (string s,
\r
437 XmlNameTable nameTable, NSResolver nsmgr)
\r
439 if (!XmlChar.IsName (s))
\r
440 throw new ArgumentException ("'" + s + "' is an invalid name.");
\r
444 internal override ValueType ParseValueType (string s, XmlNameTable nameTable, NSResolver nsmgr)
\r
446 return new StringValueType (ParseValue (s, nameTable, nsmgr) as string);
\r
451 internal class XsdNCName : XsdName
\r
453 internal XsdNCName ()
\r
457 public override XmlTokenizedType TokenizedType {
\r
458 get { return XmlTokenizedType.NCName; }
\r
462 public override XmlTypeCode TypeCode {
\r
463 get { return XmlTypeCode.NCName; }
\r
467 public override Type ValueType {
\r
468 get { return typeof (string); }
\r
471 public override object ParseValue (string s,
\r
472 XmlNameTable nameTable, NSResolver nsmgr)
\r
474 if (!XmlChar.IsNCName (s))
\r
475 throw new ArgumentException ("'" + s + "' is an invalid NCName.");
\r
479 internal override ValueType ParseValueType (string s, XmlNameTable nameTable, NSResolver nsmgr)
\r
481 return new StringValueType (ParseValue (s, nameTable, nsmgr) as string);
\r
486 internal class XsdID : XsdName
\r
492 public override XmlTokenizedType TokenizedType {
\r
493 get { return XmlTokenizedType.ID; }
\r
497 public override XmlTypeCode TypeCode {
\r
498 get { return XmlTypeCode.Id; }
\r
502 public override Type ValueType {
\r
503 get { return typeof (string); }
\r
506 public override object ParseValue (string s, XmlNameTable nt, NSResolver nsmgr)
\r
508 if (!XmlChar.IsNCName (s))
\r
509 throw new ArgumentException ("'" + s + "' is an invalid NCName.");
\r
515 internal class XsdIDRef : XsdName
\r
517 internal XsdIDRef ()
\r
521 public override XmlTokenizedType TokenizedType {
\r
522 get { return XmlTokenizedType.IDREF; }
\r
526 public override XmlTypeCode TypeCode {
\r
527 get { return XmlTypeCode.Idref; }
\r
531 public override Type ValueType {
\r
532 get { return typeof (string); }
\r
535 public override object ParseValue (string s, XmlNameTable nt, NSResolver nsmgr)
\r
537 if (!XmlChar.IsNCName (s))
\r
538 throw new ArgumentException ("'" + s + "' is an invalid NCName.");
\r
544 internal class XsdIDRefs : XsdName
\r
546 internal XsdIDRefs ()
\r
550 public override XmlTokenizedType TokenizedType {
\r
551 get { return XmlTokenizedType.IDREFS; }
\r
556 public override XmlTypeCode TypeCode {
\r
557 get { return XmlTypeCode.Item; }
\r
561 public override Type ValueType {
\r
562 get { return typeof (string []); }
\r
565 public override object ParseValue (string value, XmlNameTable nt, NSResolver nsmgr)
\r
567 return GetValidatedArray (value, nt);
\r
570 internal override ValueType ParseValueType (string s, XmlNameTable nameTable, NSResolver nsmgr)
\r
572 return new StringArrayValueType (GetValidatedArray (s, nameTable));
\r
575 private string [] GetValidatedArray (string value, XmlNameTable nt)
\r
577 string [] idrefs = ParseListValue (value, nt);
\r
578 for (int i = 0; i < idrefs.Length; i++)
\r
579 XmlConvert.VerifyNCName (idrefs [i]);
\r
585 internal class XsdEntity : XsdName
\r
587 internal XsdEntity ()
\r
591 public override XmlTokenizedType TokenizedType {
\r
592 get { return XmlTokenizedType.ENTITY; }
\r
596 public override XmlTypeCode TypeCode {
\r
597 get { return XmlTypeCode.Entity; }
\r
601 public override Type ValueType {
\r
602 get { return typeof (string); }
\r
610 internal class XsdEntities : XsdName
\r
612 internal XsdEntities ()
\r
616 public override XmlTokenizedType TokenizedType {
\r
617 get { return XmlTokenizedType.ENTITIES; }
\r
622 public override XmlTypeCode TypeCode {
\r
623 get { return XmlTypeCode.Item; }
\r
627 public override Type ValueType {
\r
628 get { return typeof (string []); }
\r
631 public override object ParseValue (string value, XmlNameTable nt, NSResolver nsmgr)
\r
633 return GetValidatedArray (value, nt);
\r
636 internal override ValueType ParseValueType (string s, XmlNameTable nameTable, NSResolver nsmgr)
\r
638 return new StringArrayValueType (GetValidatedArray (s, nameTable));
\r
641 private string [] GetValidatedArray (string value, XmlNameTable nt)
\r
643 string [] entities = ParseListValue (value, nt);
\r
644 for (int i = 0; i < entities.Length; i++)
\r
645 if (!XmlChar.IsName (entities [i]))
\r
646 throw new ArgumentException ("Invalid entitiy name.");
\r
652 internal class XsdNotation : XsdAnySimpleType
\r
654 internal XsdNotation ()
\r
658 internal override XmlSchemaFacet.Facet AllowedFacets {
\r
659 get { return stringAllowedFacets; }
\r
662 public override XmlTokenizedType TokenizedType {
\r
663 get { return XmlTokenizedType.NOTATION; }
\r
667 public override XmlTypeCode TypeCode {
\r
668 get { return XmlTypeCode.Notation; }
\r
672 public override Type ValueType {
\r
673 get { return typeof (string); }
\r
676 public override object ParseValue (string s,
\r
677 XmlNameTable nameTable, NSResolver nsmgr)
\r
679 return Normalize (s);
\r
682 // Fundamental Facets
\r
683 public override bool Bounded {
\r
684 get { return false; }
\r
686 public override bool Finite {
\r
687 get { return false; }
\r
689 public override bool Numeric {
\r
690 get { return false; }
\r
692 public override XsdOrderedFacet Ordered {
\r
693 get { return XsdOrderedFacet.False; }
\r
699 internal class XsdDecimal : XsdAnySimpleType
\r
701 internal XsdDecimal ()
\r
703 this.WhitespaceValue = XsdWhitespaceFacet.Collapse;
\r
706 internal override XmlSchemaFacet.Facet AllowedFacets {
\r
707 get { return decimalAllowedFacets; }
\r
710 public override XmlTokenizedType TokenizedType {
\r
711 get { return XmlTokenizedType.None; }
\r
715 public override XmlTypeCode TypeCode {
\r
716 get { return XmlTypeCode.Decimal; }
\r
720 public override Type ValueType {
\r
721 get { return typeof (decimal); }
\r
724 public override object ParseValue (string s,
\r
725 XmlNameTable nameTable, NSResolver nsmgr)
\r
727 return ParseValueType (s, nameTable, nsmgr);
\r
730 internal override ValueType ParseValueType (string s, XmlNameTable nameTable, NSResolver nsmgr)
\r
732 return XmlConvert.ToDecimal (this.Normalize (s));
\r
735 internal override XsdOrdering Compare(object x, object y) {
\r
736 if ((x is Decimal) && (y is Decimal)) {
\r
737 int ret = Decimal.Compare((Decimal)x, (Decimal)y);
\r
739 return XsdOrdering.LessThan;
\r
741 else if (ret > 0) {
\r
742 return XsdOrdering.GreaterThan;
\r
745 return XsdOrdering.Equal;
\r
748 return XsdOrdering.Indeterminate;
\r
751 // Fundamental Facets
\r
752 public override bool Bounded {
\r
753 get { return false; }
\r
755 public override bool Finite {
\r
756 get { return false; }
\r
758 public override bool Numeric {
\r
759 get { return true; }
\r
761 public override XsdOrderedFacet Ordered {
\r
762 get { return XsdOrderedFacet.Total; }
\r
768 internal class XsdInteger : XsdDecimal
\r
770 public XsdInteger ()
\r
775 public override XmlTypeCode TypeCode {
\r
776 get { return XmlTypeCode.Integer; }
\r
780 // Here it may be bigger than int's (or long's) MaxValue.
\r
781 public override Type ValueType {
\r
782 get { return typeof (decimal); }
\r
785 public override object ParseValue (string s,
\r
786 XmlNameTable nameTable, NSResolver nsmgr)
\r
788 return ParseValueType (s, nameTable, nsmgr);
\r
791 internal override ValueType ParseValueType (string s, XmlNameTable nameTable, NSResolver nsmgr)
\r
793 decimal d = XmlConvert.ToDecimal (Normalize (s));
\r
794 if (Decimal.Floor (d) != d)
\r
795 throw new FormatException ("Integer contains point number.");
\r
804 internal class XsdLong : XsdInteger
\r
807 public override XmlTypeCode TypeCode {
\r
808 get { return XmlTypeCode.Long; }
\r
812 public override Type ValueType {
\r
813 get { return typeof (long); }
\r
816 public override object ParseValue (string s,
\r
817 XmlNameTable nameTable, NSResolver nsmgr)
\r
819 return ParseValueType (s, nameTable, nsmgr);
\r
822 internal override ValueType ParseValueType (string s, XmlNameTable nameTable, NSResolver nsmgr)
\r
824 return XmlConvert.ToInt64 (Normalize (s));
\r
827 internal override XsdOrdering Compare(object x, object y) {
\r
828 if ((x is long) && (y is long)) {
\r
829 if ((long)x==(long)y) {
\r
830 return XsdOrdering.Equal;
\r
832 else if ((long)x<(long)y) {
\r
833 return XsdOrdering.LessThan;
\r
836 return XsdOrdering.GreaterThan;
\r
839 return XsdOrdering.Indeterminate;
\r
844 internal class XsdInt : XsdLong
\r
847 public override XmlTypeCode TypeCode {
\r
848 get { return XmlTypeCode.Int; }
\r
852 public override Type ValueType {
\r
853 get { return typeof (int); }
\r
856 public override object ParseValue (string s,
\r
857 XmlNameTable nameTable, NSResolver nsmgr)
\r
859 return ParseValueType (s, nameTable, nsmgr);
\r
862 internal override ValueType ParseValueType (string s, XmlNameTable nameTable, NSResolver nsmgr)
\r
864 return XmlConvert.ToInt32 (Normalize (s));
\r
867 internal override XsdOrdering Compare(object x, object y) {
\r
868 if ((x is int) && (y is int)) {
\r
869 if ((int)x==(int)y) {
\r
870 return XsdOrdering.Equal;
\r
872 else if ((int)x<(int)y) {
\r
873 return XsdOrdering.LessThan;
\r
876 return XsdOrdering.GreaterThan;
\r
879 return XsdOrdering.Indeterminate;
\r
885 internal class XsdShort : XsdInt
\r
888 public override XmlTypeCode TypeCode {
\r
889 get { return XmlTypeCode.Short; }
\r
893 public override Type ValueType {
\r
894 get { return typeof (short); }
\r
897 public override object ParseValue (string s,
\r
898 XmlNameTable nameTable, NSResolver nsmgr)
\r
900 return ParseValueType (s, nameTable, nsmgr);
\r
903 internal override ValueType ParseValueType (string s, XmlNameTable nameTable, NSResolver nsmgr)
\r
905 return XmlConvert.ToInt16 (Normalize (s));
\r
908 internal override XsdOrdering Compare(object x, object y) {
\r
909 if ((x is short) && (y is short)) {
\r
910 if ((short)x==(short)y) {
\r
911 return XsdOrdering.Equal;
\r
913 else if ((short)x<(short)y) {
\r
914 return XsdOrdering.LessThan;
\r
917 return XsdOrdering.GreaterThan;
\r
920 return XsdOrdering.Indeterminate;
\r
925 internal class XsdByte : XsdShort
\r
928 public override XmlTypeCode TypeCode {
\r
929 get { return XmlTypeCode.Byte; }
\r
933 public override Type ValueType {
\r
934 get { return typeof (sbyte); }
\r
937 public override object ParseValue (string s,
\r
938 XmlNameTable nameTable, NSResolver nsmgr)
\r
940 return ParseValueType (s, nameTable, nsmgr);
\r
943 internal override ValueType ParseValueType (string s, XmlNameTable nameTable, NSResolver nsmgr)
\r
945 return XmlConvert.ToSByte (Normalize (s));
\r
948 internal override XsdOrdering Compare(object x, object y) {
\r
949 if ((x is sbyte) && (y is sbyte)) {
\r
950 if ((sbyte)x==(sbyte)y) {
\r
951 return XsdOrdering.Equal;
\r
953 else if ((sbyte)x<(sbyte)y) {
\r
954 return XsdOrdering.LessThan;
\r
957 return XsdOrdering.GreaterThan;
\r
960 return XsdOrdering.Indeterminate;
\r
964 // xs:nonNegativeInteger
\r
965 // [CLSCompliant (false)]
\r
966 internal class XsdNonNegativeInteger : XsdInteger
\r
969 public override XmlTypeCode TypeCode {
\r
970 get { return XmlTypeCode.NonNegativeInteger; }
\r
974 public override Type ValueType {
\r
975 get { return typeof (decimal); }
\r
978 // [CLSCompliant (false)]
\r
979 public override object ParseValue (string s,
\r
980 XmlNameTable nameTable, NSResolver nsmgr)
\r
982 return ParseValueType (s, nameTable, nsmgr);
\r
985 internal override ValueType ParseValueType (string s, XmlNameTable nameTable, NSResolver nsmgr)
\r
987 return XmlConvert.ToDecimal (Normalize (s));
\r
992 // [CLSCompliant (false)]
\r
993 internal class XsdUnsignedLong : XsdNonNegativeInteger
\r
996 public override XmlTypeCode TypeCode {
\r
997 get { return XmlTypeCode.UnsignedLong; }
\r
1001 public override Type ValueType {
\r
1002 get { return typeof (ulong); }
\r
1005 public override object ParseValue (string s,
\r
1006 XmlNameTable nameTable, NSResolver nsmgr)
\r
1008 return ParseValueType (s, nameTable, nsmgr);
\r
1011 internal override ValueType ParseValueType (string s, XmlNameTable nameTable, NSResolver nsmgr)
\r
1013 return XmlConvert.ToUInt64 (Normalize (s));
\r
1016 internal override XsdOrdering Compare(object x, object y) {
\r
1017 if ((x is ulong) && (y is ulong)) {
\r
1018 if ((ulong)x==(ulong)y) {
\r
1019 return XsdOrdering.Equal;
\r
1021 else if ((ulong)x<(ulong)y) {
\r
1022 return XsdOrdering.LessThan;
\r
1025 return XsdOrdering.GreaterThan;
\r
1028 return XsdOrdering.Indeterminate;
\r
1033 // [CLSCompliant (false)]
\r
1034 internal class XsdUnsignedInt : XsdUnsignedLong
\r
1037 public override XmlTypeCode TypeCode {
\r
1038 get { return XmlTypeCode.UnsignedInt; }
\r
1042 public override Type ValueType {
\r
1043 get { return typeof (uint); }
\r
1046 public override object ParseValue (string s,
\r
1047 XmlNameTable nameTable, NSResolver nsmgr)
\r
1049 return ParseValueType (s, nameTable, nsmgr);
\r
1052 internal override ValueType ParseValueType (string s, XmlNameTable nameTable, NSResolver nsmgr)
\r
1054 return XmlConvert.ToUInt32 (Normalize (s));
\r
1057 internal override XsdOrdering Compare(object x, object y) {
\r
1058 if ((x is uint) && (y is uint)) {
\r
1059 if ((uint)x==(uint)y) {
\r
1060 return XsdOrdering.Equal;
\r
1062 else if ((uint)x<(uint)y) {
\r
1063 return XsdOrdering.LessThan;
\r
1066 return XsdOrdering.GreaterThan;
\r
1069 return XsdOrdering.Indeterminate;
\r
1074 // xs:unsignedShort
\r
1075 // [CLSCompliant (false)]
\r
1076 internal class XsdUnsignedShort : XsdUnsignedInt
\r
1079 public override XmlTypeCode TypeCode {
\r
1080 get { return XmlTypeCode.UnsignedShort; }
\r
1084 public override Type ValueType {
\r
1085 get { return typeof (ushort); }
\r
1088 public override object ParseValue (string s,
\r
1089 XmlNameTable nameTable, NSResolver nsmgr)
\r
1091 return ParseValueType (s, nameTable, nsmgr);
\r
1094 internal override ValueType ParseValueType (string s, XmlNameTable nameTable, NSResolver nsmgr)
\r
1096 return XmlConvert.ToUInt16 (Normalize (s));
\r
1099 internal override XsdOrdering Compare(object x, object y) {
\r
1100 if ((x is ushort) && (y is ushort)) {
\r
1101 if ((ushort)x==(ushort)y) {
\r
1102 return XsdOrdering.Equal;
\r
1104 else if ((ushort)x<(ushort)y) {
\r
1105 return XsdOrdering.LessThan;
\r
1108 return XsdOrdering.GreaterThan;
\r
1111 return XsdOrdering.Indeterminate;
\r
1115 // xs:unsignedByte
\r
1116 // [CLSCompliant (false)]
\r
1117 internal class XsdUnsignedByte : XsdUnsignedShort
\r
1120 public override XmlTypeCode TypeCode {
\r
1121 get { return XmlTypeCode.UnsignedByte; }
\r
1125 public override Type ValueType {
\r
1126 get { return typeof (byte); }
\r
1129 public override object ParseValue (string s,
\r
1130 XmlNameTable nameTable, NSResolver nsmgr)
\r
1132 return ParseValueType (s, nameTable, nsmgr);
\r
1135 internal override ValueType ParseValueType (string s, XmlNameTable nameTable, NSResolver nsmgr)
\r
1137 return XmlConvert.ToByte(Normalize (s));
\r
1140 internal override XsdOrdering Compare(object x, object y) {
\r
1141 if ((x is byte) && (y is byte)) {
\r
1142 if ((byte)x==(byte)y) {
\r
1143 return XsdOrdering.Equal;
\r
1145 else if ((byte)x<(byte)y) {
\r
1146 return XsdOrdering.LessThan;
\r
1149 return XsdOrdering.GreaterThan;
\r
1152 return XsdOrdering.Indeterminate;
\r
1157 // xs:positiveInteger
\r
1158 // [CLSCompliant (false)]
\r
1159 internal class XsdPositiveInteger : XsdNonNegativeInteger
\r
1162 public override XmlTypeCode TypeCode {
\r
1163 get { return XmlTypeCode.PositiveInteger; }
\r
1167 // It returns decimal, instead of int or long.
\r
1168 // Maybe MS developers thought about big integer...
\r
1169 public override Type ValueType {
\r
1170 get { return typeof (decimal); }
\r
1173 public override object ParseValue (string s,
\r
1174 XmlNameTable nameTable, NSResolver nsmgr)
\r
1176 return ParseValueType (s, nameTable, nsmgr);
\r
1179 internal override ValueType ParseValueType (string s, XmlNameTable nameTable, NSResolver nsmgr)
\r
1181 return XmlConvert.ToDecimal (Normalize (s));
\r
1185 // xs:nonPositiveInteger
\r
1186 internal class XsdNonPositiveInteger : XsdInteger
\r
1189 public override XmlTypeCode TypeCode {
\r
1190 get { return XmlTypeCode.NonPositiveInteger; }
\r
1194 public override Type ValueType {
\r
1195 get { return typeof (decimal); }
\r
1198 public override object ParseValue (string s,
\r
1199 XmlNameTable nameTable, NSResolver nsmgr)
\r
1201 return ParseValueType (s, nameTable, nsmgr);
\r
1204 internal override ValueType ParseValueType (string s, XmlNameTable nameTable, NSResolver nsmgr)
\r
1206 return XmlConvert.ToDecimal (Normalize (s));
\r
1210 // xs:negativeInteger
\r
1211 internal class XsdNegativeInteger : XsdNonPositiveInteger
\r
1214 public override XmlTypeCode TypeCode {
\r
1215 get { return XmlTypeCode.NegativeInteger; }
\r
1219 public override Type ValueType {
\r
1221 get { return typeof (decimal); }
\r
1224 public override object ParseValue (string s,
\r
1225 XmlNameTable nameTable, NSResolver nsmgr)
\r
1227 return ParseValueType (s, nameTable, nsmgr);
\r
1230 internal override ValueType ParseValueType (string s, XmlNameTable nameTable, NSResolver nsmgr)
\r
1232 return XmlConvert.ToDecimal (Normalize (s));
\r
1237 internal class XsdFloat : XsdAnySimpleType
\r
1240 public override XmlTypeCode TypeCode {
\r
1241 get { return XmlTypeCode.Float; }
\r
1245 internal XsdFloat ()
\r
1247 this.WhitespaceValue = XsdWhitespaceFacet.Collapse;
\r
1250 internal override XmlSchemaFacet.Facet AllowedFacets {
\r
1251 get { return durationAllowedFacets; }
\r
1254 // Fundamental Facets
\r
1255 public override bool Bounded {
\r
1256 get { return true; }
\r
1258 public override bool Finite {
\r
1259 get { return true; }
\r
1261 public override bool Numeric {
\r
1262 get { return true; }
\r
1264 public override XsdOrderedFacet Ordered {
\r
1265 get { return XsdOrderedFacet.Total; }
\r
1268 public override Type ValueType {
\r
1269 get { return typeof (float); }
\r
1272 public override object ParseValue (string s,
\r
1273 XmlNameTable nameTable, NSResolver nsmgr)
\r
1275 return ParseValueType (s, nameTable, nsmgr);
\r
1278 internal override ValueType ParseValueType (string s, XmlNameTable nameTable, NSResolver nsmgr)
\r
1280 return XmlConvert.ToSingle (Normalize (s));
\r
1283 internal override XsdOrdering Compare(object x, object y) {
\r
1284 if ((x is float) && (y is float)) {
\r
1285 if ((float)x==(float)y) {
\r
1286 return XsdOrdering.Equal;
\r
1288 else if ((float)x<(float)y) {
\r
1289 return XsdOrdering.LessThan;
\r
1292 return XsdOrdering.GreaterThan;
\r
1295 return XsdOrdering.Indeterminate;
\r
1301 internal class XsdDouble : XsdAnySimpleType
\r
1303 internal XsdDouble ()
\r
1305 this.WhitespaceValue = XsdWhitespaceFacet.Collapse;
\r
1308 internal override XmlSchemaFacet.Facet AllowedFacets {
\r
1309 get { return durationAllowedFacets; }
\r
1312 // Fundamental Facets
\r
1313 public override bool Bounded {
\r
1314 get { return true; }
\r
1316 public override bool Finite {
\r
1317 get { return true; }
\r
1319 public override bool Numeric {
\r
1320 get { return true; }
\r
1322 public override XsdOrderedFacet Ordered {
\r
1323 get { return XsdOrderedFacet.Total; }
\r
1327 public override XmlTypeCode TypeCode {
\r
1328 get { return XmlTypeCode.Double; }
\r
1332 public override Type ValueType {
\r
1333 get { return typeof (double); }
\r
1336 public override object ParseValue (string s,
\r
1337 XmlNameTable nameTable, NSResolver nsmgr)
\r
1339 return ParseValueType (s, nameTable, nsmgr);
\r
1342 internal override ValueType ParseValueType (string s, XmlNameTable nameTable, NSResolver nsmgr)
\r
1344 return XmlConvert.ToDouble (Normalize (s));
\r
1347 internal override XsdOrdering Compare(object x, object y) {
\r
1348 if ((x is double) && (y is double)) {
\r
1349 if ((double)x==(double)y) {
\r
1350 return XsdOrdering.Equal;
\r
1352 else if ((double)x<(double)y) {
\r
1353 return XsdOrdering.LessThan;
\r
1356 return XsdOrdering.GreaterThan;
\r
1359 return XsdOrdering.Indeterminate;
\r
1364 // xs:base64Binary
\r
1365 internal class XsdBase64Binary : XsdString
\r
1367 internal XsdBase64Binary ()
\r
1372 public override XmlTypeCode TypeCode {
\r
1373 get { return XmlTypeCode.Base64Binary; }
\r
1377 public override Type ValueType {
\r
1378 get { return typeof (byte[]); }
\r
1381 public override object ParseValue (string s,
\r
1382 XmlNameTable nameTable, NSResolver nsmgr)
\r
1384 // If it isnt ASCII it isnt valid base64 data
\r
1385 byte[] inArr = new System.Text.ASCIIEncoding().GetBytes(s);
\r
1386 FromBase64Transform t = new FromBase64Transform();
\r
1387 return t.TransformFinalBlock(inArr, 0, inArr.Length);
\r
1391 internal override int Length(string s) {
\r
1394 int end = s.Length;
\r
1395 for (int i = 0; i < end; i++) {
\r
1397 if (!Char.IsWhiteSpace(c)) {
\r
1400 else if (isPad(c))
\r
1403 return -1; // Invalid characters
\r
1407 return -1; // Max 2 padding at the end.
\r
1411 return ((length/4)*3)+pad;
\r
1414 /* TODO: Use the Base64Table and similar code when it makes it
\r
1415 * out of System.Security.Cryptography (currently internal so I
\r
1416 * don't think we can use it).
\r
1419 private static string ALPHABET =
\r
1420 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
\r
1422 private static byte[] decodeTable;
\r
1423 static XsdBase64Binary ()
\r
1425 int len = ALPHABET.Length;
\r
1427 decodeTable = new byte [1 + (int)'z'];
\r
1429 for (int i=0; i < decodeTable.Length; i++) {
\r
1430 decodeTable [i] = Byte.MaxValue;
\r
1433 for (int i=0; i < len; i++) {
\r
1434 char ch = ALPHABET [i];
\r
1435 decodeTable [(int)ch] = (byte) i;
\r
1439 protected static bool isPad(char octect) {
\r
1440 return (octect == '=');
\r
1443 protected static bool isData(char octect) {
\r
1444 return ((octect <= 'z') && (decodeTable[octect] != Byte.MaxValue));
\r
1448 internal override ValueType ParseValueType (string s, XmlNameTable nameTable, NSResolver nsmgr)
\r
1450 return new StringValueType (ParseValue (s, nameTable, nsmgr) as string);
\r
1456 internal class XsdHexBinary : XsdAnySimpleType
\r
1458 internal XsdHexBinary ()
\r
1460 this.WhitespaceValue = XsdWhitespaceFacet.Collapse;
\r
1463 internal override XmlSchemaFacet.Facet AllowedFacets {
\r
1464 get { return stringAllowedFacets; }
\r
1468 public override XmlTypeCode TypeCode {
\r
1469 get { return XmlTypeCode.HexBinary; }
\r
1473 public override XmlTokenizedType TokenizedType {
\r
1474 get { return XmlTokenizedType.None; }
\r
1477 public override Type ValueType {
\r
1478 get { return typeof (byte []); }
\r
1481 public override object ParseValue (string s,
\r
1482 XmlNameTable nameTable, NSResolver nsmgr)
\r
1484 return XmlConvert.FromBinHexString (Normalize (s));
\r
1487 internal override int Length(string s) {
\r
1488 return s.Length / 2 + s.Length % 2 ; // Not sure if odd lengths are even allowed
\r
1491 internal override ValueType ParseValueType (string s, XmlNameTable nameTable, NSResolver nsmgr)
\r
1493 return new StringValueType (ParseValue (s, nameTable, nsmgr) as string);
\r
1496 // Fundamental Facets ... no need to override
\r
1500 internal class XsdQName : XsdName
\r
1502 internal XsdQName ()
\r
1506 // Fundamental facets are the same as anySimpleType.
\r
1508 public override XmlTokenizedType TokenizedType {
\r
1509 get { return XmlTokenizedType.QName; }
\r
1513 public override XmlTypeCode TypeCode {
\r
1514 get { return XmlTypeCode.QName; }
\r
1518 public override Type ValueType {
\r
1519 get { return typeof (XmlQualifiedName); }
\r
1522 // ParseValue () method is as same as that of xs:string
\r
1523 public override object ParseValue (string s,
\r
1524 XmlNameTable nameTable, NSResolver nsmgr)
\r
1526 if (nameTable == null)
\r
1527 throw new ArgumentNullException ("name table");
\r
1528 if (nsmgr == null)
\r
1529 throw new ArgumentNullException ("namespace manager");
\r
1530 XmlQualifiedName name = XmlQualifiedName.Parse (s, nsmgr);
\r
1531 nameTable.Add (name.Name);
\r
1532 nameTable.Add (name.Namespace);
\r
1536 internal override ValueType ParseValueType (string s, XmlNameTable nameTable, NSResolver nsmgr)
\r
1538 return new QNameValueType (ParseValue (s, nameTable, nsmgr) as XmlQualifiedName);
\r
1543 internal class XsdBoolean : XsdAnySimpleType
\r
1545 internal XsdBoolean ()
\r
1547 this.WhitespaceValue = XsdWhitespaceFacet.Collapse;
\r
1550 internal override XmlSchemaFacet.Facet AllowedFacets {
\r
1551 get { return booleanAllowedFacets; }
\r
1554 public override XmlTokenizedType TokenizedType {
\r
1555 #if BUGGY_MS_COMPLIANT
\r
1556 get { return XmlTokenizedType.None; }
\r
1558 get { return XmlTokenizedType.CDATA; }
\r
1563 public override XmlTypeCode TypeCode {
\r
1564 get { return XmlTypeCode.Boolean; }
\r
1568 public override Type ValueType {
\r
1569 get { return typeof (bool); }
\r
1572 public override object ParseValue (string s,
\r
1573 XmlNameTable nameTable, NSResolver nsmgr)
\r
1575 return ParseValueType (s, nameTable, nsmgr);
\r
1578 internal override ValueType ParseValueType (string s, XmlNameTable nameTable, NSResolver nsmgr)
\r
1580 return XmlConvert.ToBoolean (this.Normalize (s));
\r
1583 // Fundamental Facets
\r
1584 public override bool Bounded {
\r
1585 get { return false; }
\r
1587 public override bool Finite {
\r
1588 get { return true; }
\r
1590 public override bool Numeric {
\r
1591 get { return false; }
\r
1593 public override XsdOrderedFacet Ordered {
\r
1594 get { return XsdOrderedFacet.Total; }
\r
1601 internal class XsdAnyURI : XsdString
\r
1603 public override XmlTokenizedType TokenizedType {
\r
1605 get { return XmlTokenizedType.CDATA; }
\r
1609 public override XmlTypeCode TypeCode {
\r
1610 get { return XmlTypeCode.AnyUri; }
\r
1614 public override Type ValueType {
\r
1615 get { return typeof (Uri); }
\r
1618 public override object ParseValue (string s,
\r
1619 XmlNameTable nameTable, NSResolver nsmgr)
\r
1621 return new XmlSchemaUri (Normalize (s));
\r
1624 internal override ValueType ParseValueType (string s, XmlNameTable nameTable, NSResolver nsmgr)
\r
1626 return new UriValueType ((XmlSchemaUri) ParseValue (s, nameTable, nsmgr));
\r
1630 internal class XmlSchemaUri : Uri
\r
1632 public string value;
\r
1634 static bool HasValidScheme (string src)
\r
1636 int idx = src.IndexOf (':');
\r
1639 for (int i = 0; i < idx; i++) {
\r
1640 switch (src [i]) {
\r
1646 if (Char.IsLetterOrDigit (src [i]))
\r
1654 // MS BUG: Some strings that contain ':' might result in
\r
1655 // exception (MS.NET looks implemented as such).
\r
1656 public XmlSchemaUri (string src)
\r
1657 : this (src, HasValidScheme (src))
\r
1661 private XmlSchemaUri (string src, bool formal)
\r
1662 : base (formal ? src : "anyuri:" + src, !formal)
\r
1667 public static bool operator == (XmlSchemaUri v1, XmlSchemaUri v2)
\r
1669 return v1.value == v2.value;
\r
1672 public static bool operator != (XmlSchemaUri v1, XmlSchemaUri v2)
\r
1674 return v1.value != v2.value;
\r
1677 public override bool Equals (object obj)
\r
1679 if (obj is XmlSchemaUri)
\r
1680 return (XmlSchemaUri) obj == this;
\r
1685 public override int GetHashCode ()
\r
1687 return value.GetHashCode ();
\r
1690 public override string ToString ()
\r
1697 internal class XsdDuration : XsdAnySimpleType
\r
1699 internal XsdDuration ()
\r
1701 this.WhitespaceValue = XsdWhitespaceFacet.Collapse;
\r
1704 internal override XmlSchemaFacet.Facet AllowedFacets {
\r
1705 get { return durationAllowedFacets; }
\r
1708 public override XmlTokenizedType TokenizedType {
\r
1709 get { return XmlTokenizedType.CDATA; }
\r
1713 public override XmlTypeCode TypeCode {
\r
1714 get { return XmlTypeCode.Duration; }
\r
1718 public override Type ValueType {
\r
1719 get { return typeof (TimeSpan); }
\r
1722 public override object ParseValue (string s,
\r
1723 XmlNameTable nameTable, NSResolver nsmgr)
\r
1725 return ParseValueType (s, nameTable, nsmgr);
\r
1728 internal override ValueType ParseValueType (string s, XmlNameTable nameTable, NSResolver nsmgr)
\r
1730 return XmlConvert.ToTimeSpan (Normalize (s));
\r
1733 internal override XsdOrdering Compare(object x, object y) {
\r
1734 /* FIXME: This is really simple so far
\r
1736 * In fact in order to do this correctly in XmlSchema, we cannot use TimeSpan as the base type
\r
1737 * Though it turns out that MS .NET is a little broken in this regard too. Not doing comparisons
\r
1740 if ((x is TimeSpan) && (y is TimeSpan)) {
\r
1741 int ret = TimeSpan.Compare((TimeSpan)x, (TimeSpan)y);
\r
1743 return XsdOrdering.LessThan;
\r
1745 else if (ret > 0) {
\r
1746 return XsdOrdering.GreaterThan;
\r
1749 return XsdOrdering.Equal;
\r
1752 return XsdOrdering.Indeterminate;
\r
1756 // Fundamental Facets
\r
1757 public override bool Bounded {
\r
1758 get { return false; }
\r
1760 public override bool Finite {
\r
1761 get { return false; }
\r
1763 public override bool Numeric {
\r
1764 get { return false; }
\r
1766 public override XsdOrderedFacet Ordered {
\r
1767 get { return XsdOrderedFacet.Partial; }
\r
1773 // xdt:dayTimeDuration
\r
1774 internal class XdtDayTimeDuration : XsdDuration
\r
1776 internal XdtDayTimeDuration ()
\r
1780 public override XmlTypeCode TypeCode {
\r
1781 get { return XmlTypeCode.DayTimeDuration; }
\r
1784 public override Type ValueType {
\r
1785 get { return typeof (TimeSpan); }
\r
1788 public override object ParseValue (string s,
\r
1789 XmlNameTable nameTable, NSResolver nsmgr)
\r
1791 return ParseValueType (s, nameTable, nsmgr);
\r
1794 internal override ValueType ParseValueType (string s, XmlNameTable nameTable, NSResolver nsmgr)
\r
1796 return XmlConvert.ToTimeSpan (Normalize (s));
\r
1799 // FIXME: Fundamental Facets
\r
1800 public override bool Bounded {
\r
1801 get { return false; }
\r
1803 public override bool Finite {
\r
1804 get { return false; }
\r
1806 public override bool Numeric {
\r
1807 get { return false; }
\r
1809 public override XsdOrderedFacet Ordered {
\r
1810 get { return XsdOrderedFacet.Partial; }
\r
1815 // xdt:yearMonthDuration
\r
1816 internal class XdtYearMonthDuration : XsdDuration
\r
1818 internal XdtYearMonthDuration ()
\r
1822 public override XmlTypeCode TypeCode {
\r
1823 get { return XmlTypeCode.YearMonthDuration; }
\r
1826 public override Type ValueType {
\r
1827 get { return typeof (TimeSpan); }
\r
1830 public override object ParseValue (string s,
\r
1831 XmlNameTable nameTable, NSResolver nsmgr)
\r
1833 return ParseValueType (s, nameTable, nsmgr);
\r
1836 internal override ValueType ParseValueType (string s, XmlNameTable nameTable, NSResolver nsmgr)
\r
1838 return XmlConvert.ToTimeSpan (Normalize (s));
\r
1841 // FIXME: Fundamental Facets
\r
1842 public override bool Bounded {
\r
1843 get { return false; }
\r
1845 public override bool Finite {
\r
1846 get { return false; }
\r
1848 public override bool Numeric {
\r
1849 get { return false; }
\r
1851 public override XsdOrderedFacet Ordered {
\r
1852 get { return XsdOrderedFacet.Partial; }
\r
1859 internal class XsdDateTime : XsdAnySimpleType
\r
1861 internal XsdDateTime ()
\r
1863 this.WhitespaceValue = XsdWhitespaceFacet.Collapse;
\r
1866 internal override XmlSchemaFacet.Facet AllowedFacets {
\r
1867 get { return durationAllowedFacets; }
\r
1870 public override XmlTokenizedType TokenizedType {
\r
1871 get { return XmlTokenizedType.CDATA; }
\r
1875 public override XmlTypeCode TypeCode {
\r
1876 get { return XmlTypeCode.DateTime; }
\r
1880 public override Type ValueType {
\r
1881 get { return typeof (DateTime); }
\r
1884 public override object ParseValue (string s,
\r
1885 XmlNameTable nameTable, NSResolver nsmgr)
\r
1887 return ParseValueType (s, nameTable, nsmgr);
\r
1890 internal override ValueType ParseValueType (string s, XmlNameTable nameTable, NSResolver nsmgr)
\r
1892 return XmlConvert.ToDateTime (Normalize (s));
\r
1895 internal override XsdOrdering Compare(object x, object y) {
\r
1896 /* Really simple so far */
\r
1897 if ((x is DateTime) && (y is DateTime)) {
\r
1898 int ret = DateTime.Compare((DateTime)x, (DateTime)y);
\r
1900 return XsdOrdering.LessThan;
\r
1902 else if (ret > 0) {
\r
1903 return XsdOrdering.GreaterThan;
\r
1906 return XsdOrdering.Equal;
\r
1909 return XsdOrdering.Indeterminate;
\r
1912 // Fundamental Facets
\r
1913 public override bool Bounded {
\r
1914 get { return false; }
\r
1916 public override bool Finite {
\r
1917 get { return false; }
\r
1919 public override bool Numeric {
\r
1920 get { return false; }
\r
1922 public override XsdOrderedFacet Ordered {
\r
1923 get { return XsdOrderedFacet.Partial; }
\r
1929 internal class XsdDate : XsdAnySimpleType
\r
1931 internal XsdDate ()
\r
1933 this.WhitespaceValue = XsdWhitespaceFacet.Collapse;
\r
1936 internal override XmlSchemaFacet.Facet AllowedFacets {
\r
1937 get { return durationAllowedFacets; }
\r
1940 public override XmlTokenizedType TokenizedType {
\r
1941 get { return XmlTokenizedType.CDATA; }
\r
1945 public override XmlTypeCode TypeCode {
\r
1946 get { return XmlTypeCode.Date; }
\r
1950 public override Type ValueType {
\r
1951 get { return typeof (DateTime); }
\r
1954 public override object ParseValue (string s,
\r
1955 XmlNameTable nameTable, NSResolver nsmgr)
\r
1957 return ParseValueType (s, nameTable, nsmgr);
\r
1960 internal override ValueType ParseValueType (string s, XmlNameTable nameTable, NSResolver nsmgr)
\r
1962 return DateTime.ParseExact (Normalize (s), "yyyy-MM-dd", null);
\r
1965 internal override XsdOrdering Compare(object x, object y) {
\r
1966 /* Really simple so far */
\r
1967 if ((x is DateTime) && (y is DateTime)) {
\r
1968 int ret = DateTime.Compare((DateTime)x, (DateTime)y);
\r
1970 return XsdOrdering.LessThan;
\r
1972 else if (ret > 0) {
\r
1973 return XsdOrdering.GreaterThan;
\r
1976 return XsdOrdering.Equal;
\r
1979 return XsdOrdering.Indeterminate;
\r
1981 // Fundamental Facets ... no need to override except for Ordered.
\r
1982 public override XsdOrderedFacet Ordered {
\r
1983 get { return XsdOrderedFacet.Partial; }
\r
1989 internal class XsdTime : XsdAnySimpleType
\r
1991 static string [] timeFormats = new string [] {
\r
1992 // copied from XmlConvert.
\r
1999 "HH:mm:ss.ffffff",
\r
2000 "HH:mm:ss.fffffff",
\r
2004 "HH:mm:ss.fffzzz",
\r
2005 "HH:mm:ss.ffffzzz",
\r
2006 "HH:mm:ss.fffffzzz",
\r
2007 "HH:mm:ss.ffffffzzz",
\r
2008 "HH:mm:ss.fffffffzzz",
\r
2014 "HH:mm:ss.fffffZ",
\r
2015 "HH:mm:ss.ffffffZ",
\r
2016 "HH:mm:ss.fffffffZ"};
\r
2018 internal XsdTime ()
\r
2020 this.WhitespaceValue = XsdWhitespaceFacet.Collapse;
\r
2023 internal override XmlSchemaFacet.Facet AllowedFacets {
\r
2024 get { return durationAllowedFacets; }
\r
2027 public override XmlTokenizedType TokenizedType {
\r
2028 get { return XmlTokenizedType.CDATA; }
\r
2032 public override XmlTypeCode TypeCode {
\r
2033 get { return XmlTypeCode.Time; }
\r
2037 public override Type ValueType {
\r
2038 get { return typeof (DateTime); }
\r
2041 public override object ParseValue (string s,
\r
2042 XmlNameTable nameTable, NSResolver nsmgr)
\r
2044 return ParseValueType (s, nameTable, nsmgr);
\r
2047 internal override ValueType ParseValueType (string s, XmlNameTable nameTable, NSResolver nsmgr)
\r
2049 return DateTime.ParseExact (Normalize (s), timeFormats, null, DateTimeStyles.None);
\r
2052 internal override XsdOrdering Compare(object x, object y) {
\r
2053 /* Really simple so far */
\r
2054 if ((x is DateTime) && (y is DateTime)) {
\r
2055 int ret = DateTime.Compare((DateTime)x, (DateTime)y);
\r
2057 return XsdOrdering.LessThan;
\r
2059 else if (ret > 0) {
\r
2060 return XsdOrdering.GreaterThan;
\r
2063 return XsdOrdering.Equal;
\r
2066 return XsdOrdering.Indeterminate;
\r
2068 // Fundamental Facets ... no need to override except for Ordered.
\r
2069 public override XsdOrderedFacet Ordered {
\r
2070 get { return XsdOrderedFacet.Partial; }
\r
2076 internal class XsdGYearMonth : XsdAnySimpleType
\r
2078 internal XsdGYearMonth ()
\r
2080 this.WhitespaceValue = XsdWhitespaceFacet.Collapse;
\r
2083 internal override XmlSchemaFacet.Facet AllowedFacets {
\r
2084 get { return durationAllowedFacets; }
\r
2088 public override XmlTypeCode TypeCode {
\r
2089 get { return XmlTypeCode.GYearMonth; }
\r
2093 public override Type ValueType {
\r
2094 get { return typeof (DateTime); }
\r
2097 public override object ParseValue (string s,
\r
2098 XmlNameTable nameTable, NSResolver nsmgr)
\r
2100 return ParseValueType (s, nameTable, nsmgr);
\r
2103 internal override ValueType ParseValueType (string s, XmlNameTable nameTable, NSResolver nsmgr)
\r
2105 return DateTime.ParseExact (Normalize (s), "yyyy-MM", null);
\r
2108 internal override XsdOrdering Compare(object x, object y) {
\r
2109 /* Really simple so far */
\r
2110 if ((x is DateTime) && (y is DateTime)) {
\r
2111 int ret = DateTime.Compare((DateTime)x, (DateTime)y);
\r
2113 return XsdOrdering.LessThan;
\r
2115 else if (ret > 0) {
\r
2116 return XsdOrdering.GreaterThan;
\r
2119 return XsdOrdering.Equal;
\r
2122 return XsdOrdering.Indeterminate;
\r
2127 internal class XsdGMonthDay : XsdAnySimpleType
\r
2129 internal XsdGMonthDay ()
\r
2131 this.WhitespaceValue = XsdWhitespaceFacet.Collapse;
\r
2134 internal override XmlSchemaFacet.Facet AllowedFacets {
\r
2135 get { return durationAllowedFacets; }
\r
2139 public override XmlTypeCode TypeCode {
\r
2140 get { return XmlTypeCode.GMonthDay; }
\r
2144 public override Type ValueType {
\r
2145 get { return typeof (DateTime); }
\r
2148 public override object ParseValue (string s,
\r
2149 XmlNameTable nameTable, NSResolver nsmgr)
\r
2151 return ParseValueType (s, nameTable, nsmgr);
\r
2154 internal override ValueType ParseValueType (string s, XmlNameTable nameTable, NSResolver nsmgr)
\r
2156 return DateTime.ParseExact (Normalize (s), "--MM-dd", null);
\r
2159 internal override XsdOrdering Compare(object x, object y) {
\r
2160 /* Really simple so far */
\r
2161 if ((x is DateTime) && (y is DateTime)) {
\r
2162 int ret = DateTime.Compare((DateTime)x, (DateTime)y);
\r
2164 return XsdOrdering.LessThan;
\r
2166 else if (ret > 0) {
\r
2167 return XsdOrdering.GreaterThan;
\r
2170 return XsdOrdering.Equal;
\r
2173 return XsdOrdering.Indeterminate;
\r
2178 internal class XsdGYear : XsdAnySimpleType
\r
2180 internal XsdGYear ()
\r
2182 this.WhitespaceValue = XsdWhitespaceFacet.Collapse;
\r
2185 internal override XmlSchemaFacet.Facet AllowedFacets {
\r
2186 get { return durationAllowedFacets; }
\r
2190 public override XmlTypeCode TypeCode {
\r
2191 get { return XmlTypeCode.GYear; }
\r
2195 public override Type ValueType {
\r
2196 get { return typeof (DateTime); }
\r
2199 // LAMESPEC: XML Schema Datatypes allows leading '-' to identify B.C. years,
\r
2200 // but CLR DateTime does not allow such expression.
\r
2201 public override object ParseValue (string s,
\r
2202 XmlNameTable nameTable, NSResolver nsmgr)
\r
2204 return ParseValueType (s, nameTable, nsmgr);
\r
2207 internal override ValueType ParseValueType (string s, XmlNameTable nameTable, NSResolver nsmgr)
\r
2209 return DateTime.ParseExact (Normalize(s), "yyyy", null);
\r
2212 internal override XsdOrdering Compare(object x, object y) {
\r
2213 /* Really simple so far */
\r
2214 if ((x is DateTime) && (y is DateTime)) {
\r
2215 int ret = DateTime.Compare((DateTime)x, (DateTime)y);
\r
2217 return XsdOrdering.LessThan;
\r
2219 else if (ret > 0) {
\r
2220 return XsdOrdering.GreaterThan;
\r
2223 return XsdOrdering.Equal;
\r
2226 return XsdOrdering.Indeterminate;
\r
2231 internal class XsdGMonth : XsdAnySimpleType
\r
2233 internal XsdGMonth ()
\r
2235 this.WhitespaceValue = XsdWhitespaceFacet.Collapse;
\r
2238 internal override XmlSchemaFacet.Facet AllowedFacets {
\r
2239 get { return durationAllowedFacets; }
\r
2243 public override XmlTypeCode TypeCode {
\r
2244 get { return XmlTypeCode.GMonth; }
\r
2248 public override Type ValueType {
\r
2249 get { return typeof (DateTime); }
\r
2252 public override object ParseValue (string s,
\r
2253 XmlNameTable nameTable, NSResolver nsmgr)
\r
2255 return ParseValueType (s, nameTable, nsmgr);
\r
2258 internal override ValueType ParseValueType (string s, XmlNameTable nameTable, NSResolver nsmgr)
\r
2260 return DateTime.ParseExact (Normalize(s), "--MM--", null);
\r
2263 internal override XsdOrdering Compare(object x, object y) {
\r
2264 /* Really simple so far */
\r
2265 if ((x is DateTime) && (y is DateTime)) {
\r
2266 int ret = DateTime.Compare((DateTime)x, (DateTime)y);
\r
2268 return XsdOrdering.LessThan;
\r
2270 else if (ret > 0) {
\r
2271 return XsdOrdering.GreaterThan;
\r
2274 return XsdOrdering.Equal;
\r
2277 return XsdOrdering.Indeterminate;
\r
2282 internal class XsdGDay : XsdAnySimpleType
\r
2284 internal XsdGDay ()
\r
2286 this.WhitespaceValue = XsdWhitespaceFacet.Collapse;
\r
2289 internal override XmlSchemaFacet.Facet AllowedFacets {
\r
2290 get { return durationAllowedFacets; }
\r
2294 public override XmlTypeCode TypeCode {
\r
2295 get { return XmlTypeCode.GDay; }
\r
2299 public override Type ValueType {
\r
2300 get { return typeof (DateTime); }
\r
2303 public override object ParseValue (string s,
\r
2304 XmlNameTable nameTable, NSResolver nsmgr)
\r
2306 return ParseValueType (s, nameTable, nsmgr);
\r
2309 internal override ValueType ParseValueType (string s, XmlNameTable nameTable, NSResolver nsmgr)
\r
2311 return DateTime.ParseExact (Normalize(s), "---dd", null);
\r
2314 internal override XsdOrdering Compare(object x, object y) {
\r
2315 /* Really simple so far */
\r
2316 if ((x is DateTime) && (y is DateTime)) {
\r
2317 int ret = DateTime.Compare((DateTime)x, (DateTime)y);
\r
2319 return XsdOrdering.LessThan;
\r
2321 else if (ret > 0) {
\r
2322 return XsdOrdering.GreaterThan;
\r
2325 return XsdOrdering.Equal;
\r
2328 return XsdOrdering.Indeterminate;
\r