/// <summary>
/// Returns a simple type which extends the basic datatype and
/// restricts is using the string validator
/// </summary>
public override XmlSchemaSimpleType GetSimpleType(string attributeDataType)
{
var retVal = base.GetSimpleType(attributeDataType);
var restriction = (XmlSchemaSimpleTypeRestriction) retVal.Content;
var sva = (StringValidatorAttribute) Attribute;
if (!string.IsNullOrEmpty(sva.InvalidCharacters))
{
var pFacet = new XmlSchemaPatternFacet { Value = sva.InvalidCharacters };
// TODO: convert this to a regex that excludes the characters
pFacet.Value = string.Format(
"[^{0}]*",
pFacet.Value
.Replace(@"\", @"\\")
.Replace(@"[", @"\[")
.Replace(@"]", @"\]"));
restriction.Facets.Add(pFacet);
}
var minFacet = new XmlSchemaMinLengthFacet { Value = sva.MinLength.ToString() };
restriction.Facets.Add(minFacet);
var maxFacet = new XmlSchemaMaxLengthFacet { Value = sva.MaxLength.ToString() };
restriction.Facets.Add(maxFacet);
return retVal;
}
/// <summary>
/// Returns a simple type which extends the basic datatype and
/// restricts it using a regex pattern
/// </summary>
public override XmlSchemaSimpleType GetSimpleType(string attributeDataType)
{
var retVal = base.GetSimpleType(attributeDataType);
var restriction = (XmlSchemaSimpleTypeRestriction) retVal.Content;
var rxa = (RegexStringValidatorAttribute) Attribute;
var pFacet = new XmlSchemaPatternFacet { Value = rxa.Regex };
restriction.Facets.Add(pFacet);
return retVal;
}
public FacetsCompiler(DatatypeImplementation baseDatatype, RestrictionFacets restriction) {
firstPattern = true;
regStr = null;
pattern_facet = null;
datatype = baseDatatype;
derivedRestriction = restriction;
baseFlags = datatype.Restriction != null ? datatype.Restriction.Flags : 0;
baseFixedFlags = datatype.Restriction != null ? datatype.Restriction.FixedFlags : 0;
validRestrictionFlags = datatype.ValidRestrictionFlags;
nonNegativeInt = DatatypeImplementation.GetSimpleTypeFromTypeCode(XmlTypeCode.NonNegativeInteger).Datatype;
builtInEnum = !(datatype is Datatype_union || datatype is Datatype_List) ? datatype.TypeCode : 0;
builtInType = (int)builtInEnum > 0 ? DatatypeImplementation.GetSimpleTypeFromTypeCode(builtInEnum).Datatype : datatype;
}
public FacetsCompiler(DatatypeImplementation baseDatatype, RestrictionFacets restriction)
{
this.firstPattern = true;
this.regStr = null;
this.pattern_facet = null;
this.datatype = baseDatatype;
this.derivedRestriction = restriction;
this.baseFlags = (this.datatype.Restriction != null) ? this.datatype.Restriction.Flags : ((RestrictionFlags)0);
this.baseFixedFlags = (this.datatype.Restriction != null) ? this.datatype.Restriction.FixedFlags : ((RestrictionFlags)0);
this.validRestrictionFlags = this.datatype.ValidRestrictionFlags;
this.nonNegativeInt = DatatypeImplementation.GetSimpleTypeFromTypeCode(XmlTypeCode.NonNegativeInteger).Datatype;
this.builtInEnum = (!(this.datatype is Datatype_union) && !(this.datatype is Datatype_List)) ? this.datatype.TypeCode : XmlTypeCode.None;
this.builtInType = (this.builtInEnum > XmlTypeCode.None) ? DatatypeImplementation.GetSimpleTypeFromTypeCode(this.builtInEnum).Datatype : this.datatype;
}
public FacetsCompiler(DatatypeImplementation baseDatatype, RestrictionFacets restriction)
{
_firstPattern = true;
_regStr = null;
_pattern_facet = null;
_datatype = baseDatatype;
_derivedRestriction = restriction;
_baseFlags = _datatype.Restriction != null ? _datatype.Restriction.Flags : 0;
_baseFixedFlags = _datatype.Restriction != null ? _datatype.Restriction.FixedFlags : 0;
_validRestrictionFlags = _datatype.ValidRestrictionFlags;
_nonNegativeInt = DatatypeImplementation.GetSimpleTypeFromTypeCode(XmlTypeCode.NonNegativeInteger).Datatype;
_builtInEnum = !(_datatype is Datatype_union || _datatype is Datatype_List) ? _datatype.TypeCode : 0;
_builtInType = (int)_builtInEnum > 0 ? DatatypeImplementation.GetSimpleTypeFromTypeCode(_builtInEnum).Datatype : _datatype;
}
internal void CompilePatternFacet(XmlSchemaPatternFacet facet)
{
this.CheckProhibitedFlag(facet, RestrictionFlags.Pattern, "Sch_PatternFacetProhibited");
if (this.firstPattern)
{
this.regStr = new StringBuilder();
this.regStr.Append("(");
this.regStr.Append(facet.Value);
this.pattern_facet = facet;
this.firstPattern = false;
}
else
{
this.regStr.Append(")|(");
this.regStr.Append(facet.Value);
}
this.SetFlag(facet, RestrictionFlags.Pattern);
}
public TypeData (Type type, string elementName, bool isPrimitive, TypeData mappedType, XmlSchemaPatternFacet facet)
{
#if NET_2_0
if (type.IsGenericTypeDefinition)
throw new InvalidOperationException ("Generic type definition cannot be used in serialization. Only specific generic types can be used.");
#endif
this.mappedType = mappedType;
this.facet = facet;
this.type = type;
this.typeName = type.Name;
this.fullTypeName = type.FullName.Replace ('+', '.');
if (isPrimitive)
sType = SchemaTypes.Primitive;
else
{
if (type.IsEnum)
sType = SchemaTypes.Enum;
else if (typeof(IXmlSerializable).IsAssignableFrom (type))
sType = SchemaTypes.XmlSerializable;
else if (typeof (System.Xml.XmlNode).IsAssignableFrom (type))
sType = SchemaTypes.XmlNode;
else if (type.IsArray || typeof(IEnumerable).IsAssignableFrom (type))
sType = SchemaTypes.Array;
else
sType = SchemaTypes.Class;
}
if (IsListType)
this.elementName = TypeTranslator.GetArrayName (ListItemTypeData.XmlType);
else
this.elementName = elementName;
if (sType == SchemaTypes.Array || sType == SchemaTypes.Class) {
hasPublicConstructor = !type.IsInterface && (type.IsArray || type.GetConstructor (Type.EmptyTypes) != null || type.IsAbstract || type.IsValueType);
}
}
static TypeScope()
{
AddPrimitive(typeof(string), "string", "String", TypeFlags.HasDefaultConstructor | TypeFlags.CanBeElementValue | TypeFlags.CanBeTextValue | TypeFlags.CanBeAttributeValue | TypeFlags.Reference);
AddPrimitive(typeof(int), "int", "Int32", TypeFlags.XmlEncodingNotRequired | TypeFlags.CanBeElementValue | TypeFlags.CanBeAttributeValue);
AddPrimitive(typeof(bool), "boolean", "Boolean", TypeFlags.XmlEncodingNotRequired | TypeFlags.CanBeElementValue | TypeFlags.CanBeAttributeValue);
AddPrimitive(typeof(short), "short", "Int16", TypeFlags.XmlEncodingNotRequired | TypeFlags.CanBeElementValue | TypeFlags.CanBeAttributeValue);
AddPrimitive(typeof(long), "long", "Int64", TypeFlags.XmlEncodingNotRequired | TypeFlags.CanBeElementValue | TypeFlags.CanBeAttributeValue);
AddPrimitive(typeof(float), "float", "Single", TypeFlags.XmlEncodingNotRequired | TypeFlags.CanBeElementValue | TypeFlags.CanBeAttributeValue);
AddPrimitive(typeof(double), "double", "Double", TypeFlags.XmlEncodingNotRequired | TypeFlags.CanBeElementValue | TypeFlags.CanBeAttributeValue);
AddPrimitive(typeof(decimal), "decimal", "Decimal", TypeFlags.XmlEncodingNotRequired | TypeFlags.CanBeElementValue | TypeFlags.CanBeAttributeValue);
AddPrimitive(typeof(DateTime), "dateTime", "DateTime", TypeFlags.XmlEncodingNotRequired | TypeFlags.HasCustomFormatter | TypeFlags.CanBeElementValue | TypeFlags.CanBeAttributeValue);
AddPrimitive(typeof(XmlQualifiedName), "QName", "XmlQualifiedName", TypeFlags.XmlEncodingNotRequired | TypeFlags.HasIsEmpty | TypeFlags.HasCustomFormatter | TypeFlags.CanBeElementValue | TypeFlags.CanBeAttributeValue | TypeFlags.Reference);
AddPrimitive(typeof(byte), "unsignedByte", "Byte", TypeFlags.XmlEncodingNotRequired | TypeFlags.CanBeElementValue | TypeFlags.CanBeAttributeValue);
AddPrimitive(typeof(sbyte), "byte", "SByte", TypeFlags.XmlEncodingNotRequired | TypeFlags.CanBeElementValue | TypeFlags.CanBeAttributeValue);
AddPrimitive(typeof(ushort), "unsignedShort", "UInt16", TypeFlags.XmlEncodingNotRequired | TypeFlags.CanBeElementValue | TypeFlags.CanBeAttributeValue);
AddPrimitive(typeof(uint), "unsignedInt", "UInt32", TypeFlags.XmlEncodingNotRequired | TypeFlags.CanBeElementValue | TypeFlags.CanBeAttributeValue);
AddPrimitive(typeof(ulong), "unsignedLong", "UInt64", TypeFlags.XmlEncodingNotRequired | TypeFlags.CanBeElementValue | TypeFlags.CanBeAttributeValue);
AddPrimitive(typeof(DateTime), "date", "Date", TypeFlags.XmlEncodingNotRequired | TypeFlags.AmbiguousDataType | TypeFlags.HasCustomFormatter | TypeFlags.CanBeElementValue | TypeFlags.CanBeAttributeValue);
AddPrimitive(typeof(DateTime), "time", "Time", TypeFlags.XmlEncodingNotRequired | TypeFlags.AmbiguousDataType | TypeFlags.HasCustomFormatter | TypeFlags.CanBeElementValue | TypeFlags.CanBeAttributeValue);
AddPrimitive(typeof(string), "Name", "XmlName", TypeFlags.AmbiguousDataType | TypeFlags.HasCustomFormatter | TypeFlags.CanBeElementValue | TypeFlags.CanBeAttributeValue | TypeFlags.Reference);
AddPrimitive(typeof(string), "NCName", "XmlNCName", TypeFlags.AmbiguousDataType | TypeFlags.HasCustomFormatter | TypeFlags.CanBeElementValue | TypeFlags.CanBeAttributeValue | TypeFlags.Reference);
AddPrimitive(typeof(string), "NMTOKEN", "XmlNmToken", TypeFlags.AmbiguousDataType | TypeFlags.HasCustomFormatter | TypeFlags.CanBeElementValue | TypeFlags.CanBeAttributeValue | TypeFlags.Reference);
AddPrimitive(typeof(string), "NMTOKENS", "XmlNmTokens", TypeFlags.AmbiguousDataType | TypeFlags.HasCustomFormatter | TypeFlags.CanBeElementValue | TypeFlags.CanBeAttributeValue | TypeFlags.Reference);
AddPrimitive(typeof(byte[]), "base64Binary", "ByteArrayBase64", TypeFlags.XmlEncodingNotRequired | TypeFlags.HasDefaultConstructor | TypeFlags.IgnoreDefault | TypeFlags.AmbiguousDataType | TypeFlags.HasCustomFormatter | TypeFlags.CanBeElementValue | TypeFlags.CanBeAttributeValue | TypeFlags.Reference);
AddPrimitive(typeof(byte[]), "hexBinary", "ByteArrayHex", TypeFlags.XmlEncodingNotRequired | TypeFlags.HasDefaultConstructor | TypeFlags.IgnoreDefault | TypeFlags.AmbiguousDataType | TypeFlags.HasCustomFormatter | TypeFlags.CanBeElementValue | TypeFlags.CanBeAttributeValue | TypeFlags.Reference);
XmlSchemaPatternFacet facet = new XmlSchemaPatternFacet {
Value = "[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}"
};
AddNonXsdPrimitive(typeof(Guid), "guid", "http://microsoft.com/wsdl/types/", "Guid", new XmlQualifiedName("string", "http://www.w3.org/2001/XMLSchema"), new XmlSchemaFacet[] { facet }, TypeFlags.XmlEncodingNotRequired | TypeFlags.IgnoreDefault | TypeFlags.CanBeElementValue | TypeFlags.CanBeAttributeValue);
AddNonXsdPrimitive(typeof(char), "char", "http://microsoft.com/wsdl/types/", "Char", new XmlQualifiedName("unsignedShort", "http://www.w3.org/2001/XMLSchema"), new XmlSchemaFacet[0], TypeFlags.IgnoreDefault | TypeFlags.HasCustomFormatter | TypeFlags.CanBeElementValue | TypeFlags.CanBeAttributeValue);
AddSoapEncodedTypes("http://schemas.xmlsoap.org/soap/encoding/");
AddPrimitive(typeof(string), "normalizedString", "String", TypeFlags.HasDefaultConstructor | TypeFlags.AmbiguousDataType | TypeFlags.CanBeElementValue | TypeFlags.CanBeTextValue | TypeFlags.CanBeAttributeValue | TypeFlags.Reference);
for (int i = 0; i < unsupportedTypes.Length; i++)
{
AddPrimitive(typeof(string), unsupportedTypes[i], "String", TypeFlags.CollapseWhitespace | TypeFlags.AmbiguousDataType | TypeFlags.CanBeElementValue | TypeFlags.CanBeTextValue | TypeFlags.CanBeAttributeValue | TypeFlags.Reference);
}
}
static TypeScope() {
AddPrimitive(typeof(string), "string", "String", TypeFlags.CanBeAttributeValue | TypeFlags.CanBeElementValue | TypeFlags.CanBeTextValue | TypeFlags.Reference | TypeFlags.HasDefaultConstructor);
AddPrimitive(typeof(int), "int", "Int32", TypeFlags.CanBeAttributeValue | TypeFlags.CanBeElementValue | TypeFlags.XmlEncodingNotRequired);
AddPrimitive(typeof(bool), "boolean", "Boolean", TypeFlags.CanBeAttributeValue | TypeFlags.CanBeElementValue | TypeFlags.XmlEncodingNotRequired);
AddPrimitive(typeof(short), "short", "Int16", TypeFlags.CanBeAttributeValue | TypeFlags.CanBeElementValue | TypeFlags.XmlEncodingNotRequired);
AddPrimitive(typeof(long), "long", "Int64", TypeFlags.CanBeAttributeValue | TypeFlags.CanBeElementValue | TypeFlags.XmlEncodingNotRequired);
AddPrimitive(typeof(float), "float", "Single", TypeFlags.CanBeAttributeValue | TypeFlags.CanBeElementValue | TypeFlags.XmlEncodingNotRequired);
AddPrimitive(typeof(double), "double", "Double", TypeFlags.CanBeAttributeValue | TypeFlags.CanBeElementValue | TypeFlags.XmlEncodingNotRequired);
AddPrimitive(typeof(decimal), "decimal", "Decimal", TypeFlags.CanBeAttributeValue | TypeFlags.CanBeElementValue | TypeFlags.XmlEncodingNotRequired);
AddPrimitive(typeof(DateTime), "dateTime", "DateTime", TypeFlags.CanBeAttributeValue | TypeFlags.CanBeElementValue | TypeFlags.HasCustomFormatter | TypeFlags.XmlEncodingNotRequired);
AddPrimitive(typeof(XmlQualifiedName), "QName", "XmlQualifiedName", TypeFlags.CanBeAttributeValue | TypeFlags.HasCustomFormatter | TypeFlags.HasIsEmpty | TypeFlags.CanBeElementValue | TypeFlags.XmlEncodingNotRequired | TypeFlags.Reference);
AddPrimitive(typeof(byte), "unsignedByte", "Byte", TypeFlags.CanBeAttributeValue | TypeFlags.CanBeElementValue | TypeFlags.XmlEncodingNotRequired);
AddPrimitive(typeof(SByte), "byte", "SByte", TypeFlags.CanBeAttributeValue | TypeFlags.CanBeElementValue | TypeFlags.XmlEncodingNotRequired);
AddPrimitive(typeof(UInt16), "unsignedShort", "UInt16", TypeFlags.CanBeAttributeValue | TypeFlags.CanBeElementValue | TypeFlags.XmlEncodingNotRequired);
AddPrimitive(typeof(UInt32), "unsignedInt", "UInt32", TypeFlags.CanBeAttributeValue | TypeFlags.CanBeElementValue | TypeFlags.XmlEncodingNotRequired);
AddPrimitive(typeof(UInt64), "unsignedLong", "UInt64", TypeFlags.CanBeAttributeValue | TypeFlags.CanBeElementValue | TypeFlags.XmlEncodingNotRequired);
// Types without direct mapping (ambigous)
AddPrimitive(typeof(DateTime), "date", "Date", TypeFlags.AmbiguousDataType | TypeFlags.CanBeAttributeValue | TypeFlags.CanBeElementValue | TypeFlags.HasCustomFormatter | TypeFlags.XmlEncodingNotRequired);
AddPrimitive(typeof(DateTime), "time", "Time", TypeFlags.AmbiguousDataType | TypeFlags.CanBeAttributeValue | TypeFlags.CanBeElementValue | TypeFlags.HasCustomFormatter | TypeFlags.XmlEncodingNotRequired);
AddPrimitive(typeof(string), "Name", "XmlName", TypeFlags.AmbiguousDataType | TypeFlags.CanBeAttributeValue | TypeFlags.CanBeElementValue | TypeFlags.HasCustomFormatter | TypeFlags.Reference);
AddPrimitive(typeof(string), "NCName", "XmlNCName", TypeFlags.AmbiguousDataType | TypeFlags.CanBeAttributeValue | TypeFlags.CanBeElementValue | TypeFlags.HasCustomFormatter | TypeFlags.Reference);
AddPrimitive(typeof(string), "NMTOKEN", "XmlNmToken", TypeFlags.AmbiguousDataType | TypeFlags.CanBeAttributeValue | TypeFlags.CanBeElementValue | TypeFlags.HasCustomFormatter | TypeFlags.Reference);
AddPrimitive(typeof(string), "NMTOKENS", "XmlNmTokens", TypeFlags.AmbiguousDataType | TypeFlags.CanBeAttributeValue | TypeFlags.CanBeElementValue | TypeFlags.HasCustomFormatter | TypeFlags.Reference);
AddPrimitive(typeof(byte[]), "base64Binary", "ByteArrayBase64", TypeFlags.AmbiguousDataType | TypeFlags.CanBeAttributeValue | TypeFlags.CanBeElementValue | TypeFlags.HasCustomFormatter | TypeFlags.Reference | TypeFlags.IgnoreDefault | TypeFlags.XmlEncodingNotRequired | TypeFlags.HasDefaultConstructor);
AddPrimitive(typeof(byte[]), "hexBinary", "ByteArrayHex", TypeFlags.AmbiguousDataType | TypeFlags.CanBeAttributeValue | TypeFlags.CanBeElementValue | TypeFlags.HasCustomFormatter | TypeFlags.Reference | TypeFlags.IgnoreDefault | TypeFlags.XmlEncodingNotRequired | TypeFlags.HasDefaultConstructor);
// NOTE, [....]: byte[] can also be used to mean array of bytes. That datatype is not a primitive, so we
// can't use the AmbiguousDataType mechanism. To get an array of bytes in literal XML, apply [XmlArray] or
// [XmlArrayItem].
XmlSchemaPatternFacet guidPattern = new XmlSchemaPatternFacet();
guidPattern.Value = "[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}";
AddNonXsdPrimitive(typeof(Guid), "guid", UrtTypes.Namespace, "Guid", new XmlQualifiedName("string", XmlSchema.Namespace), new XmlSchemaFacet[] { guidPattern }, TypeFlags.CanBeAttributeValue | TypeFlags.CanBeElementValue | TypeFlags.XmlEncodingNotRequired | TypeFlags.IgnoreDefault);
AddNonXsdPrimitive(typeof(char), "char", UrtTypes.Namespace, "Char", new XmlQualifiedName("unsignedShort", XmlSchema.Namespace), new XmlSchemaFacet[0], TypeFlags.CanBeAttributeValue | TypeFlags.CanBeElementValue | TypeFlags.HasCustomFormatter | TypeFlags.IgnoreDefault);
AddSoapEncodedTypes(Soap.Encoding);
// Unsuppoted types that we map to string, if in the future we decide
// to add support for them we would need to create custom formatters for them
// normalizedString is the only one unsuported type that suppose to preserve whitesapce
AddPrimitive(typeof(string), "normalizedString", "String", TypeFlags.AmbiguousDataType | TypeFlags.CanBeAttributeValue | TypeFlags.CanBeElementValue | TypeFlags.CanBeTextValue | TypeFlags.Reference | TypeFlags.HasDefaultConstructor);
for (int i = 0; i < unsupportedTypes.Length; i++) {
AddPrimitive(typeof(string), unsupportedTypes[i], "String", TypeFlags.AmbiguousDataType | TypeFlags.CanBeAttributeValue | TypeFlags.CanBeElementValue | TypeFlags.CanBeTextValue | TypeFlags.Reference | TypeFlags.CollapseWhitespace);
}
}
static TypeTranslator ()
{
nameCache = new Hashtable ();
primitiveArrayTypes = Hashtable.Synchronized (new Hashtable ());
#if !TARGET_JVM
nameCache = Hashtable.Synchronized (nameCache);
#endif
// XSD Types with direct map to CLR types
nameCache.Add (typeof (bool), new TypeData (typeof (bool), "boolean", true));
nameCache.Add (typeof (short), new TypeData (typeof (short), "short", true));
nameCache.Add (typeof (ushort), new TypeData (typeof (ushort), "unsignedShort", true));
nameCache.Add (typeof (int), new TypeData (typeof (int), "int", true));
nameCache.Add (typeof (uint), new TypeData (typeof (uint), "unsignedInt", true));
nameCache.Add (typeof (long), new TypeData (typeof (long), "long", true));
nameCache.Add (typeof (ulong), new TypeData (typeof (ulong), "unsignedLong", true));
nameCache.Add (typeof (float), new TypeData (typeof (float), "float", true));
nameCache.Add (typeof (double), new TypeData (typeof (double), "double", true));
nameCache.Add (typeof (DateTime), new TypeData (typeof (DateTime), "dateTime", true)); // TODO: timeInstant, Xml date, xml time
nameCache.Add (typeof (decimal), new TypeData (typeof (decimal), "decimal", true));
nameCache.Add (typeof (XmlQualifiedName), new TypeData (typeof (XmlQualifiedName), "QName", true));
nameCache.Add (typeof (string), new TypeData (typeof (string), "string", true));
#if !MOONLIGHT
XmlSchemaPatternFacet guidFacet = new XmlSchemaPatternFacet();
guidFacet.Value = "[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}";
nameCache.Add (typeof (Guid), new TypeData (typeof (Guid), "guid", true, (TypeData)nameCache[typeof (string)], guidFacet));
#endif
nameCache.Add (typeof (byte), new TypeData (typeof (byte), "unsignedByte", true));
nameCache.Add (typeof (sbyte), new TypeData (typeof (sbyte), "byte", true));
nameCache.Add (typeof (char), new TypeData (typeof (char), "char", true, (TypeData)nameCache[typeof (ushort)], null));
nameCache.Add (typeof (object), new TypeData (typeof (object), "anyType", false));
nameCache.Add (typeof (byte[]), new TypeData (typeof (byte[]), "base64Binary", true));
#if !MOONLIGHT
nameCache.Add (typeof (XmlNode), new TypeData (typeof (XmlNode), "XmlNode", false));
nameCache.Add (typeof (XmlElement), new TypeData (typeof (XmlElement), "XmlElement", false));
#endif
primitiveTypes = new Hashtable();
ICollection types = nameCache.Values;
foreach (TypeData td in types)
primitiveTypes.Add (td.XmlType, td);
// Additional XSD types
primitiveTypes.Add ("date", new TypeData (typeof (DateTime), "date", true)); // TODO: timeInstant
primitiveTypes.Add ("time", new TypeData (typeof (DateTime), "time", true));
primitiveTypes.Add ("timePeriod", new TypeData (typeof (DateTime), "timePeriod", true));
primitiveTypes.Add ("gDay", new TypeData (typeof (string), "gDay", true));
primitiveTypes.Add ("gMonthDay", new TypeData (typeof (string), "gMonthDay", true));
primitiveTypes.Add ("gYear", new TypeData (typeof (string), "gYear", true));
primitiveTypes.Add ("gYearMonth", new TypeData (typeof (string), "gYearMonth", true));
primitiveTypes.Add ("month", new TypeData (typeof (DateTime), "month", true));
primitiveTypes.Add ("NMTOKEN", new TypeData (typeof (string), "NMTOKEN", true));
primitiveTypes.Add ("NMTOKENS", new TypeData (typeof (string), "NMTOKENS", true));
primitiveTypes.Add ("Name", new TypeData (typeof (string), "Name", true));
primitiveTypes.Add ("NCName", new TypeData (typeof (string), "NCName", true));
primitiveTypes.Add ("language", new TypeData (typeof (string), "language", true));
primitiveTypes.Add ("integer", new TypeData (typeof (string), "integer", true));
primitiveTypes.Add ("positiveInteger", new TypeData (typeof (string), "positiveInteger", true));
primitiveTypes.Add ("nonPositiveInteger", new TypeData (typeof (string), "nonPositiveInteger", true));
primitiveTypes.Add ("negativeInteger", new TypeData (typeof (string), "negativeInteger", true));
primitiveTypes.Add ("nonNegativeInteger", new TypeData (typeof (string), "nonNegativeInteger", true));
primitiveTypes.Add ("ENTITIES", new TypeData (typeof (string), "ENTITIES", true));
primitiveTypes.Add ("ENTITY", new TypeData (typeof (string), "ENTITY", true));
primitiveTypes.Add ("hexBinary", new TypeData (typeof (byte[]), "hexBinary", true));
primitiveTypes.Add ("ID", new TypeData (typeof (string), "ID", true));
primitiveTypes.Add ("IDREF", new TypeData (typeof (string), "IDREF", true));
primitiveTypes.Add ("IDREFS", new TypeData (typeof (string), "IDREFS", true));
primitiveTypes.Add ("NOTATION", new TypeData (typeof (string), "NOTATION", true));
primitiveTypes.Add ("token", new TypeData (typeof (string), "token", true));
primitiveTypes.Add ("normalizedString", new TypeData (typeof (string), "normalizedString", true));
primitiveTypes.Add ("anyURI", new TypeData (typeof (string), "anyURI", true));
primitiveTypes.Add ("base64", new TypeData (typeof (byte[]), "base64", true));
primitiveTypes.Add ("duration", new TypeData (typeof (string), "duration", true));
#if NET_2_0
nullableTypes = Hashtable.Synchronized(new Hashtable ());
foreach (DictionaryEntry de in primitiveTypes) {
TypeData td = (TypeData) de.Value;
TypeData ntd = new TypeData (td.Type, td.XmlType, true);
ntd.IsNullable = true;
nullableTypes.Add (de.Key, ntd);
}
#endif
}
internal static XmlSchemaSimpleContentRestriction Read(XmlSchemaReader reader, ValidationEventHandler h)
{
XmlSchemaSimpleContentRestriction xmlSchemaSimpleContentRestriction = new XmlSchemaSimpleContentRestriction();
reader.MoveToElement();
if (reader.NamespaceURI != "http://www.w3.org/2001/XMLSchema" || reader.LocalName != "restriction")
{
XmlSchemaObject.error(h, "Should not happen :1: XmlSchemaComplexContentRestriction.Read, name=" + reader.Name, null);
reader.SkipToEnd();
return(null);
}
xmlSchemaSimpleContentRestriction.LineNumber = reader.LineNumber;
xmlSchemaSimpleContentRestriction.LinePosition = reader.LinePosition;
xmlSchemaSimpleContentRestriction.SourceUri = reader.BaseURI;
while (reader.MoveToNextAttribute())
{
if (reader.Name == "base")
{
Exception ex;
xmlSchemaSimpleContentRestriction.baseTypeName = XmlSchemaUtil.ReadQNameAttribute(reader, out ex);
if (ex != null)
{
XmlSchemaObject.error(h, reader.Value + " is not a valid value for base attribute", ex);
}
}
else if (reader.Name == "id")
{
xmlSchemaSimpleContentRestriction.Id = reader.Value;
}
else if ((reader.NamespaceURI == string.Empty && reader.Name != "xmlns") || reader.NamespaceURI == "http://www.w3.org/2001/XMLSchema")
{
XmlSchemaObject.error(h, reader.Name + " is not a valid attribute for restriction", null);
}
else
{
XmlSchemaUtil.ReadUnhandledAttribute(reader, xmlSchemaSimpleContentRestriction);
}
}
reader.MoveToElement();
if (reader.IsEmptyElement)
{
return(xmlSchemaSimpleContentRestriction);
}
int num = 1;
while (reader.ReadNextElement())
{
if (reader.NodeType == XmlNodeType.EndElement)
{
if (reader.LocalName != "restriction")
{
XmlSchemaObject.error(h, "Should not happen :2: XmlSchemaSimpleContentRestriction.Read, name=" + reader.Name, null);
}
break;
}
if (num <= 1 && reader.LocalName == "annotation")
{
num = 2;
XmlSchemaAnnotation xmlSchemaAnnotation = XmlSchemaAnnotation.Read(reader, h);
if (xmlSchemaAnnotation != null)
{
xmlSchemaSimpleContentRestriction.Annotation = xmlSchemaAnnotation;
}
}
else if (num <= 2 && reader.LocalName == "simpleType")
{
num = 3;
XmlSchemaSimpleType xmlSchemaSimpleType = XmlSchemaSimpleType.Read(reader, h);
if (xmlSchemaSimpleType != null)
{
xmlSchemaSimpleContentRestriction.baseType = xmlSchemaSimpleType;
}
}
else
{
if (num <= 3)
{
if (reader.LocalName == "minExclusive")
{
num = 3;
XmlSchemaMinExclusiveFacet xmlSchemaMinExclusiveFacet = XmlSchemaMinExclusiveFacet.Read(reader, h);
if (xmlSchemaMinExclusiveFacet != null)
{
xmlSchemaSimpleContentRestriction.facets.Add(xmlSchemaMinExclusiveFacet);
}
continue;
}
if (reader.LocalName == "minInclusive")
{
num = 3;
XmlSchemaMinInclusiveFacet xmlSchemaMinInclusiveFacet = XmlSchemaMinInclusiveFacet.Read(reader, h);
if (xmlSchemaMinInclusiveFacet != null)
{
xmlSchemaSimpleContentRestriction.facets.Add(xmlSchemaMinInclusiveFacet);
}
continue;
}
if (reader.LocalName == "maxExclusive")
{
num = 3;
XmlSchemaMaxExclusiveFacet xmlSchemaMaxExclusiveFacet = XmlSchemaMaxExclusiveFacet.Read(reader, h);
if (xmlSchemaMaxExclusiveFacet != null)
{
xmlSchemaSimpleContentRestriction.facets.Add(xmlSchemaMaxExclusiveFacet);
}
continue;
}
if (reader.LocalName == "maxInclusive")
{
num = 3;
XmlSchemaMaxInclusiveFacet xmlSchemaMaxInclusiveFacet = XmlSchemaMaxInclusiveFacet.Read(reader, h);
if (xmlSchemaMaxInclusiveFacet != null)
{
xmlSchemaSimpleContentRestriction.facets.Add(xmlSchemaMaxInclusiveFacet);
}
continue;
}
if (reader.LocalName == "totalDigits")
{
num = 3;
XmlSchemaTotalDigitsFacet xmlSchemaTotalDigitsFacet = XmlSchemaTotalDigitsFacet.Read(reader, h);
if (xmlSchemaTotalDigitsFacet != null)
{
xmlSchemaSimpleContentRestriction.facets.Add(xmlSchemaTotalDigitsFacet);
}
continue;
}
if (reader.LocalName == "fractionDigits")
{
num = 3;
XmlSchemaFractionDigitsFacet xmlSchemaFractionDigitsFacet = XmlSchemaFractionDigitsFacet.Read(reader, h);
if (xmlSchemaFractionDigitsFacet != null)
{
xmlSchemaSimpleContentRestriction.facets.Add(xmlSchemaFractionDigitsFacet);
}
continue;
}
if (reader.LocalName == "length")
{
num = 3;
XmlSchemaLengthFacet xmlSchemaLengthFacet = XmlSchemaLengthFacet.Read(reader, h);
if (xmlSchemaLengthFacet != null)
{
xmlSchemaSimpleContentRestriction.facets.Add(xmlSchemaLengthFacet);
}
continue;
}
if (reader.LocalName == "minLength")
{
num = 3;
XmlSchemaMinLengthFacet xmlSchemaMinLengthFacet = XmlSchemaMinLengthFacet.Read(reader, h);
if (xmlSchemaMinLengthFacet != null)
{
xmlSchemaSimpleContentRestriction.facets.Add(xmlSchemaMinLengthFacet);
}
continue;
}
if (reader.LocalName == "maxLength")
{
num = 3;
XmlSchemaMaxLengthFacet xmlSchemaMaxLengthFacet = XmlSchemaMaxLengthFacet.Read(reader, h);
if (xmlSchemaMaxLengthFacet != null)
{
xmlSchemaSimpleContentRestriction.facets.Add(xmlSchemaMaxLengthFacet);
}
continue;
}
if (reader.LocalName == "enumeration")
{
num = 3;
XmlSchemaEnumerationFacet xmlSchemaEnumerationFacet = XmlSchemaEnumerationFacet.Read(reader, h);
if (xmlSchemaEnumerationFacet != null)
{
xmlSchemaSimpleContentRestriction.facets.Add(xmlSchemaEnumerationFacet);
}
continue;
}
if (reader.LocalName == "whiteSpace")
{
num = 3;
XmlSchemaWhiteSpaceFacet xmlSchemaWhiteSpaceFacet = XmlSchemaWhiteSpaceFacet.Read(reader, h);
if (xmlSchemaWhiteSpaceFacet != null)
{
xmlSchemaSimpleContentRestriction.facets.Add(xmlSchemaWhiteSpaceFacet);
}
continue;
}
if (reader.LocalName == "pattern")
{
num = 3;
XmlSchemaPatternFacet xmlSchemaPatternFacet = XmlSchemaPatternFacet.Read(reader, h);
if (xmlSchemaPatternFacet != null)
{
xmlSchemaSimpleContentRestriction.facets.Add(xmlSchemaPatternFacet);
}
continue;
}
}
if (num <= 4)
{
if (reader.LocalName == "attribute")
{
num = 4;
XmlSchemaAttribute xmlSchemaAttribute = XmlSchemaAttribute.Read(reader, h);
if (xmlSchemaAttribute != null)
{
xmlSchemaSimpleContentRestriction.Attributes.Add(xmlSchemaAttribute);
}
continue;
}
if (reader.LocalName == "attributeGroup")
{
num = 4;
XmlSchemaAttributeGroupRef xmlSchemaAttributeGroupRef = XmlSchemaAttributeGroupRef.Read(reader, h);
if (xmlSchemaAttributeGroupRef != null)
{
xmlSchemaSimpleContentRestriction.attributes.Add(xmlSchemaAttributeGroupRef);
}
continue;
}
}
if (num <= 5 && reader.LocalName == "anyAttribute")
{
num = 6;
XmlSchemaAnyAttribute xmlSchemaAnyAttribute = XmlSchemaAnyAttribute.Read(reader, h);
if (xmlSchemaAnyAttribute != null)
{
xmlSchemaSimpleContentRestriction.AnyAttribute = xmlSchemaAnyAttribute;
}
}
else
{
reader.RaiseInvalidElementError();
}
}
}
return(xmlSchemaSimpleContentRestriction);
}
/// <summary>
/// Creates a simple type that matches a regex
/// </summary>
/// <param name="Name">Name of the new type</param>
/// <param name="Pattern">Regex pattern to match</param>
/// <returns>A simple type which will match the given pattern</returns>
static XmlSchemaSimpleType CreateSimpleTypeFromRegex(string Name, string Pattern)
{
XmlSchemaPatternFacet PatternFacet = new XmlSchemaPatternFacet();
PatternFacet.Value = Pattern;
XmlSchemaSimpleTypeRestriction Restriction = new XmlSchemaSimpleTypeRestriction();
Restriction.BaseTypeName = StringTypeName;
Restriction.Facets.Add(PatternFacet);
XmlSchemaSimpleType SimpleType = new XmlSchemaSimpleType();
SimpleType.Name = Name;
SimpleType.Content = Restriction;
return SimpleType;
}
//<restriction
//base = QName
//id = ID
//{any attributes with non-schema namespace . . .}>
//Content: (annotation?, (simpleType?, (minExclusive | minInclusive | maxExclusive | maxInclusive | totalDigits | fractionDigits | length | minLength | maxLength | enumeration | whiteSpace | pattern)*)?, ((attribute | attributeGroup)*, anyAttribute?))
//</restriction>
internal static XmlSchemaSimpleContentRestriction Read(XmlSchemaReader reader, ValidationEventHandler h)
{
XmlSchemaSimpleContentRestriction restriction = new XmlSchemaSimpleContentRestriction();
reader.MoveToElement();
if (reader.NamespaceURI != XmlSchema.Namespace || reader.LocalName != xmlname)
{
error(h, "Should not happen :1: XmlSchemaComplexContentRestriction.Read, name=" + reader.Name, null);
reader.SkipToEnd();
return(null);
}
restriction.LineNumber = reader.LineNumber;
restriction.LinePosition = reader.LinePosition;
restriction.SourceUri = reader.BaseURI;
while (reader.MoveToNextAttribute())
{
if (reader.Name == "base")
{
Exception innerex;
restriction.baseTypeName = XmlSchemaUtil.ReadQNameAttribute(reader, out innerex);
if (innerex != null)
{
error(h, reader.Value + " is not a valid value for base attribute", innerex);
}
}
else if (reader.Name == "id")
{
restriction.Id = reader.Value;
}
else if ((reader.NamespaceURI == "" && reader.Name != "xmlns") || reader.NamespaceURI == XmlSchema.Namespace)
{
error(h, reader.Name + " is not a valid attribute for restriction", null);
}
else
{
XmlSchemaUtil.ReadUnhandledAttribute(reader, restriction);
}
}
reader.MoveToElement();
if (reader.IsEmptyElement)
{
return(restriction);
}
//Content: 1.annotation?,
// 2.simpleType?,
// 3.(minExclusive |...| enumeration | whiteSpace | pattern)*,
// 4.(attribute | attributeGroup)*,
// 5.anyAttribute?
int level = 1;
while (reader.ReadNextElement())
{
if (reader.NodeType == XmlNodeType.EndElement)
{
if (reader.LocalName != xmlname)
{
error(h, "Should not happen :2: XmlSchemaSimpleContentRestriction.Read, name=" + reader.Name, null);
}
break;
}
if (level <= 1 && reader.LocalName == "annotation")
{
level = 2; //Only one annotation
XmlSchemaAnnotation annotation = XmlSchemaAnnotation.Read(reader, h);
if (annotation != null)
{
restriction.Annotation = annotation;
}
continue;
}
if (level <= 2 && reader.LocalName == "simpleType")
{
level = 3;
XmlSchemaSimpleType stype = XmlSchemaSimpleType.Read(reader, h);
if (stype != null)
{
restriction.baseType = stype;
}
continue;
}
if (level <= 3)
{
if (reader.LocalName == "minExclusive")
{
level = 3;
XmlSchemaMinExclusiveFacet minex = XmlSchemaMinExclusiveFacet.Read(reader, h);
if (minex != null)
{
restriction.facets.Add(minex);
}
continue;
}
else if (reader.LocalName == "minInclusive")
{
level = 3;
XmlSchemaMinInclusiveFacet mini = XmlSchemaMinInclusiveFacet.Read(reader, h);
if (mini != null)
{
restriction.facets.Add(mini);
}
continue;
}
else if (reader.LocalName == "maxExclusive")
{
level = 3;
XmlSchemaMaxExclusiveFacet maxex = XmlSchemaMaxExclusiveFacet.Read(reader, h);
if (maxex != null)
{
restriction.facets.Add(maxex);
}
continue;
}
else if (reader.LocalName == "maxInclusive")
{
level = 3;
XmlSchemaMaxInclusiveFacet maxi = XmlSchemaMaxInclusiveFacet.Read(reader, h);
if (maxi != null)
{
restriction.facets.Add(maxi);
}
continue;
}
else if (reader.LocalName == "totalDigits")
{
level = 3;
XmlSchemaTotalDigitsFacet total = XmlSchemaTotalDigitsFacet.Read(reader, h);
if (total != null)
{
restriction.facets.Add(total);
}
continue;
}
else if (reader.LocalName == "fractionDigits")
{
level = 3;
XmlSchemaFractionDigitsFacet fraction = XmlSchemaFractionDigitsFacet.Read(reader, h);
if (fraction != null)
{
restriction.facets.Add(fraction);
}
continue;
}
else if (reader.LocalName == "length")
{
level = 3;
XmlSchemaLengthFacet length = XmlSchemaLengthFacet.Read(reader, h);
if (length != null)
{
restriction.facets.Add(length);
}
continue;
}
else if (reader.LocalName == "minLength")
{
level = 3;
XmlSchemaMinLengthFacet minlen = XmlSchemaMinLengthFacet.Read(reader, h);
if (minlen != null)
{
restriction.facets.Add(minlen);
}
continue;
}
else if (reader.LocalName == "maxLength")
{
level = 3;
XmlSchemaMaxLengthFacet maxlen = XmlSchemaMaxLengthFacet.Read(reader, h);
if (maxlen != null)
{
restriction.facets.Add(maxlen);
}
continue;
}
else if (reader.LocalName == "enumeration")
{
level = 3;
XmlSchemaEnumerationFacet enumeration = XmlSchemaEnumerationFacet.Read(reader, h);
if (enumeration != null)
{
restriction.facets.Add(enumeration);
}
continue;
}
else if (reader.LocalName == "whiteSpace")
{
level = 3;
XmlSchemaWhiteSpaceFacet ws = XmlSchemaWhiteSpaceFacet.Read(reader, h);
if (ws != null)
{
restriction.facets.Add(ws);
}
continue;
}
else if (reader.LocalName == "pattern")
{
level = 3;
XmlSchemaPatternFacet pattern = XmlSchemaPatternFacet.Read(reader, h);
if (pattern != null)
{
restriction.facets.Add(pattern);
}
continue;
}
}
if (level <= 4)
{
if (reader.LocalName == "attribute")
{
level = 4;
XmlSchemaAttribute attr = XmlSchemaAttribute.Read(reader, h);
if (attr != null)
{
restriction.Attributes.Add(attr);
}
continue;
}
if (reader.LocalName == "attributeGroup")
{
level = 4;
XmlSchemaAttributeGroupRef attr = XmlSchemaAttributeGroupRef.Read(reader, h);
if (attr != null)
{
restriction.attributes.Add(attr);
}
continue;
}
}
if (level <= 5 && reader.LocalName == "anyAttribute")
{
level = 6;
XmlSchemaAnyAttribute anyattr = XmlSchemaAnyAttribute.Read(reader, h);
if (anyattr != null)
{
restriction.AnyAttribute = anyattr;
}
continue;
}
reader.RaiseInvalidElementError();
}
return(restriction);
}
protected override void Visit(XmlSchemaPatternFacet facet)
{
AddLeaf(SimpleTypeStructureNodeType.FacetPattern, facet);
}
private RestrictionFacets ConstructRestriction(XmlSchemaObjectCollection facets, XmlNameTable nameTable) {
RestrictionFacets restriction = new RestrictionFacets();
RestrictionFlags thisFlags = this.restriction != null ? this.restriction.Flags : 0;
RestrictionFlags fixedFlags = this.restriction != null ? this.restriction.FixedFlags : 0;
RestrictionFlags validRestrictionFlags = ValidRestrictionFlags;
if (variety == XmlSchemaDatatypeVariety.List) {
validRestrictionFlags = RestrictionFlags.Length|RestrictionFlags.MinLength|RestrictionFlags.MaxLength|RestrictionFlags.Enumeration|RestrictionFlags.WhiteSpace;
if (minListSize == 0) {
validRestrictionFlags |= RestrictionFlags.Pattern;
}
}
StringBuilder regStr = new StringBuilder();
XmlSchemaFacet pattern_facet = null;
bool firstP = true;
foreach (XmlSchemaFacet facet in facets) {
if (facet.Value == null) {
throw new XmlSchemaException(Res.Sch_InvalidFacet, facet);
}
XmlNamespaceManager nsmgr = new SchemaNamespaceManager(facet);
if (facet is XmlSchemaLengthFacet) {
CheckFixedFlag(facet, fixedFlags, RestrictionFlags.Length);
CheckProhibitedFlag(facet, validRestrictionFlags, RestrictionFlags.Length, Res.Sch_LengthFacetProhibited);
CheckDupFlag(facet, restriction, RestrictionFlags.Length, Res.Sch_DupLengthFacet);
try {
restriction.Length = (int)(decimal)c_nonNegativeInteger.ParseAtomicValue(facet.Value, null, null);
}
catch (XmlSchemaException xse) {
if (xse.SourceSchemaObject == null) {
xse.SetSource(facet);
}
throw xse;
}
catch (Exception e) {
throw new XmlSchemaException(Res.Sch_LengthFacetInvalid, e.Message, facet);
}
if ((thisFlags & RestrictionFlags.Length) != 0) {
if (this.restriction.Length < restriction.Length) {
throw new XmlSchemaException(Res.Sch_LengthGtBaseLength, facet);
}
}
SetFlag(restriction, facet, RestrictionFlags.Length);
}
else if (facet is XmlSchemaMinLengthFacet) {
CheckFixedFlag(facet, fixedFlags, RestrictionFlags.MinLength);
CheckProhibitedFlag(facet, validRestrictionFlags, RestrictionFlags.MinLength, Res.Sch_MinLengthFacetProhibited);
CheckDupFlag(facet, restriction, RestrictionFlags.MinLength, Res.Sch_DupMinLengthFacet);
try {
restriction.MinLength = (int)(decimal)c_nonNegativeInteger.ParseAtomicValue(facet.Value, null, null);
}
catch (XmlSchemaException xse) {
if (xse.SourceSchemaObject == null) {
xse.SetSource(facet);
}
throw xse;
}
catch (Exception e) {
throw new XmlSchemaException(Res.Sch_MinLengthFacetInvalid, e.Message, facet);
}
if ((thisFlags & RestrictionFlags.MinLength) != 0) {
if (this.restriction.MinLength > restriction.MinLength) {
throw new XmlSchemaException(Res.Sch_MinLengthGtBaseMinLength, facet);
}
}
SetFlag(restriction, facet, RestrictionFlags.MinLength);
}
else if (facet is XmlSchemaMaxLengthFacet) {
CheckFixedFlag(facet, fixedFlags, RestrictionFlags.MaxLength);
CheckProhibitedFlag(facet, validRestrictionFlags, RestrictionFlags.MaxLength, Res.Sch_MaxLengthFacetProhibited);
CheckDupFlag(facet, restriction, RestrictionFlags.MaxLength, Res.Sch_DupMaxLengthFacet);
try {
restriction.MaxLength = (int)(decimal)c_nonNegativeInteger.ParseAtomicValue(facet.Value, null, null);
}
catch (XmlSchemaException xse) {
if (xse.SourceSchemaObject == null) {
xse.SetSource(facet);
}
throw xse;
}
catch (Exception e) {
throw new XmlSchemaException(Res.Sch_MaxLengthFacetInvalid, e.Message, facet);
}
if ((thisFlags & RestrictionFlags.MaxLength) != 0) {
if (this.restriction.MaxLength < restriction.MaxLength) {
throw new XmlSchemaException(Res.Sch_MaxLengthGtBaseMaxLength, facet);
}
}
SetFlag(restriction, facet, RestrictionFlags.MaxLength);
}
else if (facet is XmlSchemaPatternFacet) {
CheckProhibitedFlag(facet, validRestrictionFlags, RestrictionFlags.Pattern, Res.Sch_PatternFacetProhibited);
if(firstP == true) {
regStr.Append("(");
regStr.Append(facet.Value);
pattern_facet = new XmlSchemaPatternFacet();
pattern_facet = facet;
firstP = false;
}
else {
regStr.Append(")|(");
regStr.Append(facet.Value);
}
SetFlag(restriction, facet, RestrictionFlags.Pattern);
}
else if (facet is XmlSchemaEnumerationFacet) {
CheckProhibitedFlag(facet, validRestrictionFlags, RestrictionFlags.Enumeration, Res.Sch_EnumerationFacetProhibited);
if (restriction.Enumeration == null) {
restriction.Enumeration = new ArrayList();
}
try {
//restriction.Enumeration.Add(ParseAtomicValue(facet.Value, nameTable, nsmgr));
restriction.Enumeration.Add(ParseValue(facet.Value, nameTable, nsmgr));
}
catch (XmlSchemaException xse) {
if (xse.SourceSchemaObject == null) {
xse.SetSource(facet);
}
throw xse;
}
catch (Exception e) {
throw new XmlSchemaException(Res.Sch_EnumerationFacetInvalid, e.Message, facet);
}
SetFlag(restriction, facet, RestrictionFlags.Enumeration);
}
else if (facet is XmlSchemaWhiteSpaceFacet) {
CheckFixedFlag(facet, fixedFlags, RestrictionFlags.WhiteSpace);
CheckProhibitedFlag(facet, validRestrictionFlags, RestrictionFlags.WhiteSpace, Res.Sch_WhiteSpaceFacetProhibited);
CheckDupFlag(facet, restriction, RestrictionFlags.WhiteSpace, Res.Sch_DupWhiteSpaceFacet);
if (facet.Value == "preserve") {
restriction.WhiteSpace = XmlSchemaWhiteSpace.Preserve;
}
else if (facet.Value == "replace") {
restriction.WhiteSpace = XmlSchemaWhiteSpace.Replace;
}
else if (facet.Value == "collapse") {
restriction.WhiteSpace = XmlSchemaWhiteSpace.Collapse;
}
else {
throw new XmlSchemaException(Res.Sch_InvalidWhiteSpace, facet.Value, facet);
}
if (IsWhitespaceCollapseFixed && (restriction.WhiteSpace != XmlSchemaWhiteSpace.Collapse)) {
throw new XmlSchemaException(Res.Sch_InvalidWhiteSpace, facet.Value, facet);
}
if ((thisFlags & RestrictionFlags.WhiteSpace) != 0) {
if (
this.restriction.WhiteSpace == XmlSchemaWhiteSpace.Collapse &&
(restriction.WhiteSpace == XmlSchemaWhiteSpace.Replace || restriction.WhiteSpace == XmlSchemaWhiteSpace.Preserve)
) {
throw new XmlSchemaException(Res.Sch_WhiteSpaceRestriction1, facet);
}
if (
this.restriction.WhiteSpace == XmlSchemaWhiteSpace.Preserve &&
restriction.WhiteSpace == XmlSchemaWhiteSpace.Replace
) {
throw new XmlSchemaException(Res.Sch_WhiteSpaceRestriction2, facet);
}
}
SetFlag(restriction, facet, RestrictionFlags.WhiteSpace);
}
else if (facet is XmlSchemaMaxInclusiveFacet) {
CheckFixedFlag(facet, fixedFlags, RestrictionFlags.Length);
CheckProhibitedFlag(facet, validRestrictionFlags, RestrictionFlags.MaxInclusive, Res.Sch_MaxInclusiveFacetProhibited);
CheckDupFlag(facet, restriction, RestrictionFlags.MaxInclusive, Res.Sch_DupMaxInclusiveFacet);
try {
restriction.MaxInclusive = ParseAtomicValue(facet.Value, nameTable, nsmgr);
}
catch (XmlSchemaException xse) {
if (xse.SourceSchemaObject == null) {
xse.SetSource(facet);
}
throw xse;
}
catch (Exception e) {
throw new XmlSchemaException(Res.Sch_MaxInclusiveFacetInvalid, e.Message, facet);
}
CheckValue(restriction.MaxInclusive, facet, thisFlags);
SetFlag(restriction, facet, RestrictionFlags.MaxInclusive);
}
else if (facet is XmlSchemaMaxExclusiveFacet) {
CheckFixedFlag(facet, fixedFlags, RestrictionFlags.MaxExclusive);
CheckProhibitedFlag(facet, validRestrictionFlags, RestrictionFlags.MaxExclusive, Res.Sch_MaxExclusiveFacetProhibited);
CheckDupFlag(facet, restriction, RestrictionFlags.MaxExclusive, Res.Sch_DupMaxExclusiveFacet);
try {
restriction.MaxExclusive = ParseAtomicValue(facet.Value, nameTable, nsmgr);
}
catch (XmlSchemaException xse) {
if (xse.SourceSchemaObject == null) {
xse.SetSource(facet);
}
throw xse;
}
catch (Exception e) {
throw new XmlSchemaException(Res.Sch_MaxExclusiveFacetInvalid, e.Message, facet);
}
CheckValue(restriction.MaxExclusive, facet, thisFlags);
SetFlag(restriction, facet, RestrictionFlags.MaxExclusive);
}
else if (facet is XmlSchemaMinInclusiveFacet) {
CheckFixedFlag(facet, fixedFlags, RestrictionFlags.MinInclusive);
CheckProhibitedFlag(facet, validRestrictionFlags, RestrictionFlags.MinInclusive, Res.Sch_MinInclusiveFacetProhibited);
CheckDupFlag(facet, restriction, RestrictionFlags.MinInclusive, Res.Sch_DupMinInclusiveFacet);
try {
restriction.MinInclusive = ParseAtomicValue(facet.Value, nameTable, nsmgr);
}
catch (XmlSchemaException xse) {
if (xse.SourceSchemaObject == null) {
xse.SetSource(facet);
}
throw xse;
}
catch (Exception e) {
throw new XmlSchemaException(Res.Sch_MinInclusiveFacetInvalid, e.Message, facet);
}
CheckValue(restriction.MinInclusive, facet, thisFlags);
SetFlag(restriction, facet, RestrictionFlags.MinInclusive);
}
else if (facet is XmlSchemaMinExclusiveFacet) {
CheckFixedFlag(facet, fixedFlags, RestrictionFlags.MinExclusive);
CheckProhibitedFlag(facet, validRestrictionFlags, RestrictionFlags.MinExclusive, Res.Sch_MinExclusiveFacetProhibited);
CheckDupFlag(facet, restriction, RestrictionFlags.MinExclusive, Res.Sch_DupMinExclusiveFacet);
try {
restriction.MinExclusive = ParseAtomicValue(facet.Value, nameTable, nsmgr);
}
catch (XmlSchemaException xse) {
if (xse.SourceSchemaObject == null) {
xse.SetSource(facet);
}
throw xse;
}
catch (Exception e) {
throw new XmlSchemaException(Res.Sch_MinExclusiveFacetInvalid, e.Message, facet);
}
CheckValue(restriction.MinExclusive, facet, thisFlags);
SetFlag(restriction, facet, RestrictionFlags.MinExclusive);
}
else if (facet is XmlSchemaTotalDigitsFacet) {
CheckFixedFlag(facet, fixedFlags, RestrictionFlags.TotalDigits);
CheckProhibitedFlag(facet, validRestrictionFlags, RestrictionFlags.TotalDigits, Res.Sch_TotalDigitsFacetProhibited);
CheckDupFlag(facet, restriction, RestrictionFlags.TotalDigits, Res.Sch_DupTotalDigitsFacet);
try {
restriction.TotalDigits = (int)(decimal)c_positiveInteger.ParseAtomicValue(facet.Value, null, null);
}
catch (XmlSchemaException xse) {
if (xse.SourceSchemaObject == null) {
xse.SetSource(facet);
}
throw xse;
}
catch (Exception e) {
throw new XmlSchemaException(Res.Sch_TotalDigitsFacetInvalid, e.Message, facet);
}
SetFlag(restriction, facet, RestrictionFlags.TotalDigits);
}
else if (facet is XmlSchemaFractionDigitsFacet) {
CheckFixedFlag(facet, fixedFlags, RestrictionFlags.FractionDigits);
CheckProhibitedFlag(facet, validRestrictionFlags, RestrictionFlags.FractionDigits, Res.Sch_FractionDigitsFacetProhibited);
CheckDupFlag(facet, restriction, RestrictionFlags.FractionDigits, Res.Sch_DupFractionDigitsFacet);
try {
restriction.FractionDigits = (int)(decimal)c_nonNegativeInteger.ParseAtomicValue(facet.Value, null, null);
if ((restriction.FractionDigits != 0) && (this.GetType() != typeof(Datatype_decimal))) {
throw new XmlSchemaException(Res.Sch_FractionDigitsNotOnDecimal, facet);
}
}
catch (XmlSchemaException xse) {
if (xse.SourceSchemaObject == null) {
xse.SetSource(facet);
}
throw xse;
}
catch (Exception e) {
throw new XmlSchemaException(Res.Sch_FractionDigitsFacetInvalid, e.Message, facet);
}
SetFlag(restriction, facet, RestrictionFlags.FractionDigits);
}
else {
throw new XmlSchemaException(Res.Sch_UnknownFacet, facet);
}
}
//If facet is XMLSchemaPattern, then the String built inside the loop
//needs to be converted to a RegEx
if(firstP == false) {
if (restriction.Patterns == null) {
restriction.Patterns = new ArrayList();
}
try {
regStr.Append(")");
string tempStr = regStr.ToString();
if(tempStr.IndexOf("|") != -1) {
regStr.Insert(0,"(");
regStr.Append(")");
}
restriction.Patterns.Add(new Regex(Preprocess(regStr.ToString()), RegexOptions.None));
}catch (Exception e) {
throw new XmlSchemaException(Res.Sch_PatternFacetInvalid, e.Message, pattern_facet);
}
}
// Copy from the base
if (
(restriction.Flags & RestrictionFlags.Length) == 0 &&
(thisFlags & RestrictionFlags.Length) != 0
) {
restriction.Length = this.restriction.Length;
SetFlag(restriction, fixedFlags, RestrictionFlags.Length);
}
if (
(restriction.Flags & RestrictionFlags.MinLength) == 0 &&
(thisFlags & RestrictionFlags.MinLength) != 0
) {
restriction.MinLength = this.restriction.MinLength;
SetFlag(restriction, fixedFlags, RestrictionFlags.MinLength);
}
if (
(restriction.Flags & RestrictionFlags.MaxLength) == 0 &&
(thisFlags & RestrictionFlags.MaxLength) != 0
) {
restriction.MaxLength = this.restriction.MaxLength;
SetFlag(restriction, fixedFlags, RestrictionFlags.MaxLength);
}
if ((thisFlags & RestrictionFlags.Pattern) != 0) {
if (restriction.Patterns == null) {
restriction.Patterns = this.restriction.Patterns;
}
else {
restriction.Patterns.AddRange(this.restriction.Patterns);
}
SetFlag(restriction, fixedFlags, RestrictionFlags.Pattern);
}
if ((thisFlags & RestrictionFlags.Enumeration) != 0) {
if (restriction.Enumeration == null) {
restriction.Enumeration = this.restriction.Enumeration;
}
SetFlag(restriction, fixedFlags, RestrictionFlags.Enumeration);
}
if (
(restriction.Flags & RestrictionFlags.WhiteSpace) == 0 &&
(thisFlags & RestrictionFlags.WhiteSpace) != 0
) {
restriction.WhiteSpace = this.restriction.WhiteSpace;
SetFlag(restriction, fixedFlags, RestrictionFlags.WhiteSpace);
}
if (
(restriction.Flags & RestrictionFlags.MaxInclusive) == 0 &&
(thisFlags & RestrictionFlags.MaxInclusive) != 0
) {
restriction.MaxInclusive = this.restriction.MaxInclusive;
SetFlag(restriction, fixedFlags, RestrictionFlags.MaxInclusive);
}
if (
(restriction.Flags & RestrictionFlags.MaxExclusive) == 0 &&
(thisFlags & RestrictionFlags.MaxExclusive) != 0
) {
restriction.MaxExclusive = this.restriction.MaxExclusive;
SetFlag(restriction, fixedFlags, RestrictionFlags.MaxExclusive);
}
if (
(restriction.Flags & RestrictionFlags.MinInclusive) == 0 &&
(thisFlags & RestrictionFlags.MinInclusive) != 0
) {
restriction.MinInclusive = this.restriction.MinInclusive;
SetFlag(restriction, fixedFlags, RestrictionFlags.MinInclusive);
}
if (
(restriction.Flags & RestrictionFlags.MinExclusive) == 0 &&
(thisFlags & RestrictionFlags.MinExclusive) != 0
) {
restriction.MinExclusive = this.restriction.MinExclusive;
SetFlag(restriction, fixedFlags, RestrictionFlags.MinExclusive);
}
if (
(restriction.Flags & RestrictionFlags.TotalDigits) == 0 &&
(thisFlags & RestrictionFlags.TotalDigits) != 0
) {
restriction.MinExclusive = this.restriction.TotalDigits;
SetFlag(restriction, fixedFlags, RestrictionFlags.TotalDigits);
}
if (
(restriction.Flags & RestrictionFlags.FractionDigits) == 0 &&
(thisFlags & RestrictionFlags.FractionDigits) != 0
) {
restriction.FractionDigits = this.restriction.FractionDigits;
SetFlag(restriction, fixedFlags, RestrictionFlags.FractionDigits);
}
// Check combinations
if (
(restriction.Flags & RestrictionFlags.Length) != 0 &&
(restriction.Flags & (RestrictionFlags.MinLength|RestrictionFlags.MaxLength)) != 0
) {
throw new XmlSchemaException(Res.Sch_LengthAndMinMax);
}
if (
(restriction.Flags & RestrictionFlags.MinLength) != 0 &&
(restriction.Flags & RestrictionFlags.MaxLength) != 0
) {
if (restriction.MinLength > restriction.MaxLength) {
throw new XmlSchemaException(Res.Sch_MinLengthGtMaxLength);
}
}
if (
(restriction.Flags & RestrictionFlags.MaxInclusive) != 0 &&
(restriction.Flags & RestrictionFlags.MaxExclusive) != 0
) {
throw new XmlSchemaException(Res.Sch_MaxInclusiveExclusive);
}
if (
(restriction.Flags & RestrictionFlags.MinInclusive) != 0 &&
(restriction.Flags & RestrictionFlags.MinExclusive) != 0
) {
throw new XmlSchemaException(Res.Sch_MinInclusiveExclusive);
}
if (
(restriction.Flags & RestrictionFlags.MinInclusive) != 0 &&
(restriction.Flags & RestrictionFlags.MaxInclusive) != 0
) {
if (Compare(restriction.MinInclusive, restriction.MaxInclusive) > 0) {
throw new XmlSchemaException(Res.Sch_MinInclusiveGtMaxInclusive);
}
}
if (
(restriction.Flags & RestrictionFlags.MinInclusive) != 0 &&
(restriction.Flags & RestrictionFlags.MaxExclusive) != 0
) {
if (Compare(restriction.MinInclusive, restriction.MaxExclusive) > 0) {
throw new XmlSchemaException(Res.Sch_MinInclusiveGtMaxExclusive);
}
}
if (
(restriction.Flags & RestrictionFlags.MinExclusive) != 0 &&
(restriction.Flags & RestrictionFlags.MaxExclusive) != 0
) {
if (Compare(restriction.MinExclusive, restriction.MaxExclusive) > 0) {
throw new XmlSchemaException(Res.Sch_MinExclusiveGtMaxExclusive);
}
}
if (
(restriction.Flags & RestrictionFlags.MinExclusive) != 0 &&
(restriction.Flags & RestrictionFlags.MaxInclusive) != 0
) {
if (Compare(restriction.MinExclusive, restriction.MaxInclusive) > 0) {
throw new XmlSchemaException(Res.Sch_MinExclusiveGtMaxInclusive);
}
}
if ((restriction.Flags & (RestrictionFlags.TotalDigits|RestrictionFlags.FractionDigits)) == (RestrictionFlags.TotalDigits|RestrictionFlags.FractionDigits)) {
if (restriction.FractionDigits > restriction.TotalDigits) {
throw new XmlSchemaException(Res.Sch_FractionDigitsGtTotalDigits);
}
}
return restriction;
}
public FacetsCompiler(DatatypeImplementation baseDatatype, RestrictionFacets restriction)
{
this.firstPattern = true;
this.regStr = null;
this.pattern_facet = null;
this.datatype = baseDatatype;
this.derivedRestriction = restriction;
this.baseFlags = (this.datatype.Restriction != null) ? this.datatype.Restriction.Flags : ((RestrictionFlags) 0);
this.baseFixedFlags = (this.datatype.Restriction != null) ? this.datatype.Restriction.FixedFlags : ((RestrictionFlags) 0);
this.validRestrictionFlags = this.datatype.ValidRestrictionFlags;
this.nonNegativeInt = DatatypeImplementation.GetSimpleTypeFromTypeCode(XmlTypeCode.NonNegativeInteger).Datatype;
this.builtInEnum = (!(this.datatype is Datatype_union) && !(this.datatype is Datatype_List)) ? this.datatype.TypeCode : XmlTypeCode.None;
this.builtInType = (this.builtInEnum > XmlTypeCode.None) ? DatatypeImplementation.GetSimpleTypeFromTypeCode(this.builtInEnum).Datatype : this.datatype;
}
private void Write25_XmlSchemaPatternFacet(string n, string ns, XmlSchemaPatternFacet o, bool isNullable, bool needType)
{
if (o == null)
{
if (isNullable)
{
base.WriteNullTagLiteral(n, ns);
}
}
else
{
if (!needType && !(o.GetType() == typeof(XmlSchemaPatternFacet)))
{
throw base.CreateUnknownTypeException(o);
}
base.EscapeName = false;
base.WriteStartElement(n, ns, o, false, o.Namespaces);
if (needType)
{
base.WriteXsiType("XmlSchemaPatternFacet", "http://www.w3.org/2001/XMLSchema");
}
base.WriteAttribute("id", "", o.Id);
XmlAttribute[] unhandledAttributes = o.UnhandledAttributes;
if (unhandledAttributes != null)
{
for (int i = 0; i < unhandledAttributes.Length; i++)
{
XmlAttribute node = unhandledAttributes[i];
base.WriteXmlAttribute(node, o);
}
}
base.WriteAttribute("value", "", o.Value);
if (o.IsFixed)
{
base.WriteAttribute("fixed", "", XmlConvert.ToString(o.IsFixed));
}
this.Write11_XmlSchemaAnnotation("annotation", "http://www.w3.org/2001/XMLSchema", o.Annotation, false, false);
base.WriteEndElement(o);
}
}
internal void CompilePatternFacet(XmlSchemaPatternFacet facet) {
CheckProhibitedFlag(facet, RestrictionFlags.Pattern, Res.Sch_PatternFacetProhibited);
if(firstPattern == true) {
regStr = new StringBuilder();
regStr.Append("(");
regStr.Append(facet.Value);
pattern_facet = facet;
firstPattern = false;
}
else {
regStr.Append(")|(");
regStr.Append(facet.Value);
}
SetFlag(facet, RestrictionFlags.Pattern);
}
internal void CompilePatternFacet(XmlSchemaPatternFacet facet)
{
this.CheckProhibitedFlag(facet, RestrictionFlags.Pattern, "Sch_PatternFacetProhibited");
if (this.firstPattern)
{
this.regStr = new StringBuilder();
this.regStr.Append("(");
this.regStr.Append(facet.Value);
this.pattern_facet = facet;
this.firstPattern = false;
}
else
{
this.regStr.Append(")|(");
this.regStr.Append(facet.Value);
}
this.SetFlag(facet, RestrictionFlags.Pattern);
}
static TypeScope() {
AddPrimitive(typeof(string), "string", "String", TypeFlags.CanBeAttributeValue | TypeFlags.CanBeElementValue | TypeFlags.CanBeTextValue | TypeFlags.Reference);
AddPrimitive(typeof(int), "int", "Int32", TypeFlags.CanBeAttributeValue | TypeFlags.CanBeElementValue | TypeFlags.XmlEncodingNotRequired);
AddPrimitive(typeof(bool), "boolean", "Boolean", TypeFlags.CanBeAttributeValue | TypeFlags.CanBeElementValue | TypeFlags.XmlEncodingNotRequired);
AddPrimitive(typeof(short), "short", "Int16", TypeFlags.CanBeAttributeValue | TypeFlags.CanBeElementValue | TypeFlags.XmlEncodingNotRequired);
AddPrimitive(typeof(long), "long", "Int64", TypeFlags.CanBeAttributeValue | TypeFlags.CanBeElementValue | TypeFlags.XmlEncodingNotRequired);
AddPrimitive(typeof(float), "float", "Single", TypeFlags.CanBeAttributeValue | TypeFlags.CanBeElementValue | TypeFlags.XmlEncodingNotRequired);
AddPrimitive(typeof(double), "double", "Double", TypeFlags.CanBeAttributeValue | TypeFlags.CanBeElementValue | TypeFlags.XmlEncodingNotRequired);
AddPrimitive(typeof(decimal), "decimal", "Decimal", TypeFlags.CanBeAttributeValue | TypeFlags.CanBeElementValue | TypeFlags.XmlEncodingNotRequired);
AddPrimitive(typeof(DateTime), "dateTime", "DateTime", TypeFlags.CanBeAttributeValue | TypeFlags.CanBeElementValue | TypeFlags.HasCustomFormatter | TypeFlags.XmlEncodingNotRequired);
AddPrimitive(typeof(XmlQualifiedName), "QName", "XmlQualifiedName", TypeFlags.CanBeAttributeValue | TypeFlags.HasCustomFormatter | TypeFlags.HasIsEmpty | TypeFlags.CanBeElementValue | TypeFlags.XmlEncodingNotRequired);
AddPrimitive(typeof(byte), "unsignedByte", "Byte", TypeFlags.CanBeAttributeValue | TypeFlags.CanBeElementValue | TypeFlags.XmlEncodingNotRequired);
AddPrimitive(typeof(SByte), "byte", "SByte", TypeFlags.CanBeAttributeValue | TypeFlags.CanBeElementValue | TypeFlags.XmlEncodingNotRequired);
AddPrimitive(typeof(UInt16), "unsignedShort", "UInt16", TypeFlags.CanBeAttributeValue | TypeFlags.CanBeElementValue | TypeFlags.XmlEncodingNotRequired);
AddPrimitive(typeof(UInt32), "unsignedInt", "UInt32", TypeFlags.CanBeAttributeValue | TypeFlags.CanBeElementValue | TypeFlags.XmlEncodingNotRequired);
AddPrimitive(typeof(UInt64), "unsignedLong", "UInt64", TypeFlags.CanBeAttributeValue | TypeFlags.CanBeElementValue | TypeFlags.XmlEncodingNotRequired);
// Types without direct mapping (ambigous)
AddPrimitive(typeof(DateTime), "date", "Date", TypeFlags.AmbiguousDataType | TypeFlags.CanBeAttributeValue | TypeFlags.CanBeElementValue | TypeFlags.HasCustomFormatter | TypeFlags.XmlEncodingNotRequired);
AddPrimitive(typeof(DateTime), "time", "Time", TypeFlags.AmbiguousDataType | TypeFlags.CanBeAttributeValue | TypeFlags.CanBeElementValue | TypeFlags.HasCustomFormatter | TypeFlags.XmlEncodingNotRequired);
AddPrimitive(typeof(string), "Name", "XmlName", TypeFlags.AmbiguousDataType | TypeFlags.CanBeAttributeValue | TypeFlags.CanBeElementValue | TypeFlags.HasCustomFormatter | TypeFlags.Reference);
AddPrimitive(typeof(string), "NCName", "XmlNCName", TypeFlags.AmbiguousDataType | TypeFlags.CanBeAttributeValue | TypeFlags.CanBeElementValue | TypeFlags.HasCustomFormatter | TypeFlags.Reference);
AddPrimitive(typeof(string), "NMTOKEN", "XmlNmToken", TypeFlags.AmbiguousDataType | TypeFlags.CanBeAttributeValue | TypeFlags.CanBeElementValue | TypeFlags.HasCustomFormatter | TypeFlags.Reference);
AddPrimitive(typeof(string), "NMTOKENS", "XmlNmTokens", TypeFlags.AmbiguousDataType | TypeFlags.CanBeAttributeValue | TypeFlags.CanBeElementValue | TypeFlags.HasCustomFormatter | TypeFlags.Reference);
AddPrimitive(typeof(byte[]), "base64Binary", "ByteArrayBase64", TypeFlags.AmbiguousDataType | TypeFlags.CanBeAttributeValue | TypeFlags.CanBeElementValue | TypeFlags.HasCustomFormatter | TypeFlags.Reference | TypeFlags.IgnoreDefault | TypeFlags.XmlEncodingNotRequired);
AddPrimitive(typeof(byte[]), "hexBinary", "ByteArrayHex", TypeFlags.AmbiguousDataType | TypeFlags.CanBeAttributeValue | TypeFlags.CanBeElementValue | TypeFlags.HasCustomFormatter | TypeFlags.Reference | TypeFlags.IgnoreDefault | TypeFlags.XmlEncodingNotRequired);
XmlSchemaPatternFacet guidPattern = new XmlSchemaPatternFacet();
guidPattern.Value = "[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}";
AddNonXsdPrimitive(typeof(Guid), "guid", UrtTypes.Namespace, "Guid", new XmlQualifiedName("string", XmlSchema.Namespace), new XmlSchemaFacet[] { guidPattern }, TypeFlags.CanBeAttributeValue | TypeFlags.CanBeElementValue | TypeFlags.XmlEncodingNotRequired);
AddNonXsdPrimitive(typeof(char), "char", UrtTypes.Namespace, "Char", new XmlQualifiedName("unsignedShort", XmlSchema.Namespace), new XmlSchemaFacet[0], TypeFlags.CanBeAttributeValue | TypeFlags.CanBeElementValue | TypeFlags.HasCustomFormatter);
AddSoapEncodedTypes(Soap.Encoding);
// Unsuppoted types that we map to string, if in the future we decide
// to add support for them we would need to create custom formatters for them
for (int i = 0; i < unsupportedTypes.Length; i++) {
AddPrimitive(typeof(string), unsupportedTypes[i], "String", TypeFlags.AmbiguousDataType | TypeFlags.CanBeAttributeValue | TypeFlags.CanBeElementValue | TypeFlags.CanBeTextValue | TypeFlags.Reference);
}
}
protected virtual void Visit(XmlSchemaPatternFacet facet)
{
}
public XsdSimpleRestrictionType (RelaxngDatatype primitive, RelaxngParamList parameters)
{
type = new XmlSchemaSimpleType ();
XmlSchemaSimpleTypeRestriction r =
new XmlSchemaSimpleTypeRestriction ();
type.Content = r;
string ns = primitive.NamespaceURI;
// Remap XML Schema datatypes namespace -> XML Schema namespace.
if (ns == "http://www.w3.org/2001/XMLSchema-datatypes")
ns = XSchema.Namespace;
r.BaseTypeName = new XmlQualifiedName (primitive.Name, ns);
foreach (RelaxngParam p in parameters) {
XmlSchemaFacet f = null;
string value = p.Value;
switch (p.Name) {
case "maxExclusive":
f = new XmlSchemaMaxExclusiveFacet ();
break;
case "maxInclusive":
f = new XmlSchemaMaxInclusiveFacet ();
break;
case "minExclusive":
f = new XmlSchemaMinExclusiveFacet ();
break;
case "minInclusive":
f = new XmlSchemaMinInclusiveFacet ();
break;
case "pattern":
f = new XmlSchemaPatternFacet ();
// .NET/Mono Regex has a bug that it does not support "IsLatin-1Supplement"
// (it somehow breaks at '-').
value = value.Replace ("\\p{IsLatin-1Supplement}", "[\\x80-\\xFF]");
break;
case "whiteSpace":
f = new XmlSchemaWhiteSpaceFacet ();
break;
case "length":
f = new XmlSchemaLengthFacet ();
break;
case "maxLength":
f = new XmlSchemaMaxLengthFacet ();
break;
case "minLength":
f = new XmlSchemaMinLengthFacet ();
break;
case "fractionDigits":
f = new XmlSchemaFractionDigitsFacet ();
break;
case "totalDigits":
f = new XmlSchemaTotalDigitsFacet ();
break;
default:
throw new RelaxngException (String.Format ("XML Schema facet {0} is not recognized or not supported.", p.Name));
}
f.Value = value;
r.Facets.Add (f);
}
// Now we create XmlSchema to handle simple-type
// based validation (since there is no other way,
// because of sucky XmlSchemaSimpleType design).
schema = new XSchema ();
XmlSchemaElement el = new XmlSchemaElement ();
el.Name = "root";
el.SchemaType = type;
schema.Items.Add (el);
schema.Compile (null);
}
internal static XmlSchemaPatternFacet Read(XmlSchemaReader reader, ValidationEventHandler h)
{
XmlSchemaPatternFacet xmlSchemaPatternFacet = new XmlSchemaPatternFacet();
reader.MoveToElement();
if (reader.NamespaceURI != "http://www.w3.org/2001/XMLSchema" || reader.LocalName != "pattern")
{
XmlSchemaObject.error(h, "Should not happen :1: XmlSchemaPatternFacet.Read, name=" + reader.Name, null);
reader.Skip();
return(null);
}
xmlSchemaPatternFacet.LineNumber = reader.LineNumber;
xmlSchemaPatternFacet.LinePosition = reader.LinePosition;
xmlSchemaPatternFacet.SourceUri = reader.BaseURI;
while (reader.MoveToNextAttribute())
{
if (reader.Name == "id")
{
xmlSchemaPatternFacet.Id = reader.Value;
}
else if (reader.Name == "value")
{
xmlSchemaPatternFacet.Value = reader.Value;
}
else if ((reader.NamespaceURI == string.Empty && reader.Name != "xmlns") || reader.NamespaceURI == "http://www.w3.org/2001/XMLSchema")
{
XmlSchemaObject.error(h, reader.Name + " is not a valid attribute for pattern", null);
}
else
{
XmlSchemaUtil.ReadUnhandledAttribute(reader, xmlSchemaPatternFacet);
}
}
reader.MoveToElement();
if (reader.IsEmptyElement)
{
return(xmlSchemaPatternFacet);
}
int num = 1;
while (reader.ReadNextElement())
{
if (reader.NodeType == XmlNodeType.EndElement)
{
if (reader.LocalName != "pattern")
{
XmlSchemaObject.error(h, "Should not happen :2: XmlSchemaPatternFacet.Read, name=" + reader.Name, null);
}
break;
}
if (num <= 1 && reader.LocalName == "annotation")
{
num = 2;
XmlSchemaAnnotation xmlSchemaAnnotation = XmlSchemaAnnotation.Read(reader, h);
if (xmlSchemaAnnotation != null)
{
xmlSchemaPatternFacet.Annotation = xmlSchemaAnnotation;
}
}
else
{
reader.RaiseInvalidElementError();
}
}
return(xmlSchemaPatternFacet);
}
//<pattern
// id = ID
// value = anySimpleType
// {any attributes with non-schema namespace . . .}>
// Content: (annotation?)
//</pattern>
internal static XmlSchemaPatternFacet Read(XmlSchemaReader reader, ValidationEventHandler h)
{
XmlSchemaPatternFacet pattern = new XmlSchemaPatternFacet();
reader.MoveToElement();
if(reader.NamespaceURI != XmlSchema.Namespace || reader.LocalName != xmlname)
{
error(h,"Should not happen :1: XmlSchemaPatternFacet.Read, name="+reader.Name,null);
reader.Skip();
return null;
}
pattern.LineNumber = reader.LineNumber;
pattern.LinePosition = reader.LinePosition;
pattern.SourceUri = reader.BaseURI;
while(reader.MoveToNextAttribute())
{
if(reader.Name == "id")
{
pattern.Id = reader.Value;
}
else if(reader.Name == "value")
{
pattern.Value = reader.Value;
}
else if((reader.NamespaceURI == "" && reader.Name != "xmlns") || reader.NamespaceURI == XmlSchema.Namespace)
{
error(h,reader.Name + " is not a valid attribute for "+xmlname,null);
}
else
{
XmlSchemaUtil.ReadUnhandledAttribute(reader,pattern);
}
}
reader.MoveToElement();
if(reader.IsEmptyElement)
return pattern;
// Content: (annotation?)
int level = 1;
while(reader.ReadNextElement())
{
if(reader.NodeType == XmlNodeType.EndElement)
{
if(reader.LocalName != xmlname)
error(h,"Should not happen :2: XmlSchemaPatternFacet.Read, name="+reader.Name,null);
break;
}
if(level <= 1 && reader.LocalName == "annotation")
{
level = 2; //Only one annotation
XmlSchemaAnnotation annotation = XmlSchemaAnnotation.Read(reader,h);
if(annotation != null)
pattern.Annotation = annotation;
continue;
}
reader.RaiseInvalidElementError();
}
return pattern;
}
//<pattern
// id = ID
// value = anySimpleType
// {any attributes with non-schema namespace . . .}>
// Content: (annotation?)
//</pattern>
internal static XmlSchemaPatternFacet Read(XmlSchemaReader reader, ValidationEventHandler h)
{
XmlSchemaPatternFacet pattern = new XmlSchemaPatternFacet();
reader.MoveToElement();
if (reader.NamespaceURI != XmlSchema.Namespace || reader.LocalName != xmlname)
{
error(h, "Should not happen :1: XmlSchemaPatternFacet.Read, name=" + reader.Name, null);
reader.Skip();
return(null);
}
pattern.LineNumber = reader.LineNumber;
pattern.LinePosition = reader.LinePosition;
pattern.SourceUri = reader.BaseURI;
while (reader.MoveToNextAttribute())
{
if (reader.Name == "id")
{
pattern.Id = reader.Value;
}
else if (reader.Name == "value")
{
pattern.Value = reader.Value;
}
else if ((reader.NamespaceURI == "" && reader.Name != "xmlns") || reader.NamespaceURI == XmlSchema.Namespace)
{
error(h, reader.Name + " is not a valid attribute for " + xmlname, null);
}
else
{
XmlSchemaUtil.ReadUnhandledAttribute(reader, pattern);
}
}
reader.MoveToElement();
if (reader.IsEmptyElement)
{
return(pattern);
}
// Content: (annotation?)
int level = 1;
while (reader.ReadNextElement())
{
if (reader.NodeType == XmlNodeType.EndElement)
{
if (reader.LocalName != xmlname)
{
error(h, "Should not happen :2: XmlSchemaPatternFacet.Read, name=" + reader.Name, null);
}
break;
}
if (level <= 1 && reader.LocalName == "annotation")
{
level = 2; //Only one annotation
XmlSchemaAnnotation annotation = XmlSchemaAnnotation.Read(reader, h);
if (annotation != null)
{
pattern.Annotation = annotation;
}
continue;
}
reader.RaiseInvalidElementError();
}
return(pattern);
}