mcs/class/System.XML/System.Xml.Schema/XmlSchemaAnyAttribute.cs

   1 //\r
   2 // System.Xml.Schema.XmlSchemaAnyAttribute.cs\r
   3 //\r
   4 // Author:\r
   5 //      Dwivedi, Ajay kumar  Adwiv@Yahoo.com\r
   6 //      Atsushi Enomoto  ginga@kit.hi-ho.ne.jp\r
   7 //\r
   8 using System;\r
   9 using System.Collections;\r
  10 using System.Collections.Specialized;\r
  11 using System.Xml;\r
  12 using System.ComponentModel;\r
  13 using System.Xml.Serialization;\r
  14 using Mono.Xml.Schema;\r
  15 \r
  16 namespace System.Xml.Schema\r
  17 {\r
  18         /// <summary>\r
  19         /// Summary description for XmlSchemaAnyAttribute.\r
  20         /// </summary>\r
  21         public class XmlSchemaAnyAttribute : XmlSchemaAnnotated\r
  22         {\r
  23                 private string nameSpace;\r
  24                 private XmlSchemaContentProcessing processing;\r
  25                 const string xmlname = "anyAttribute";\r
  26                 private XsdWildcard wildcard;\r
  27 \r
  28                 public XmlSchemaAnyAttribute()\r
  29                 {\r
  30                         wildcard = new XsdWildcard (this);\r
  31                 }\r
  32 \r
  33                 [System.Xml.Serialization.XmlAttribute("namespace")]\r
  34                 public string Namespace \r
  35                 { \r
  36                         get{ return nameSpace; } \r
  37                         set{ nameSpace = value; } \r
  38                 }\r
  39                 \r
  40                 [DefaultValue(XmlSchemaContentProcessing.None)]\r
  41                 [System.Xml.Serialization.XmlAttribute("processContents")]\r
  42                 public XmlSchemaContentProcessing ProcessContents \r
  43                 { \r
  44                         get{ return processing; } \r
  45                         set{ processing = value; }\r
  46                 }\r
  47 \r
  48                 // Internal\r
  49                 internal bool HasValueAny {\r
  50                         get { return wildcard.HasValueAny; }\r
  51                 }\r
  52 \r
  53                 internal bool HasValueLocal {\r
  54                         get { return wildcard.HasValueLocal; }\r
  55                 }\r
  56 \r
  57                 internal bool HasValueOther {\r
  58                         get { return wildcard.HasValueOther; }\r
  59                 }\r
  60 \r
  61                 internal bool HasValueTargetNamespace {\r
  62                         get { return wildcard.HasValueTargetNamespace; }\r
  63                 }\r
  64 \r
  65                 internal StringCollection ResolvedNamespaces {\r
  66                         get { return wildcard.ResolvedNamespaces; }\r
  67                 }\r
  68 \r
  69                 internal XmlSchemaContentProcessing ResolvedProcessContents \r
  70                 { \r
  71                         get{ return wildcard.ResolvedProcessing; } \r
  72                 }\r
  73 \r
  74                 internal string TargetNamespace\r
  75                 {\r
  76                         get { return wildcard.TargetNamespace; }\r
  77                 }\r
  78 \r
  79                 /// <remarks>\r
  80                 /// 1. id must be of type ID\r
  81                 /// 2. namespace can have one of the following values:\r
  82                 ///             a) ##any or ##other\r
  83                 ///             b) list of anyURI and ##targetNamespace and ##local\r
  84                 /// </remarks>\r
  85                 internal override int Compile(ValidationEventHandler h, XmlSchema schema)\r
  86                 {\r
  87                         // If this is already compiled this time, simply skip.\r
  88                         if (this.IsComplied (schema.CompilationId))\r
  89                                 return 0;\r
  90 \r
  91                         errorCount = 0;\r
  92 \r
  93                         wildcard.TargetNamespace = schema.TargetNamespace;\r
  94                         if (wildcard.TargetNamespace == null)\r
  95                                 wildcard.TargetNamespace = "";\r
  96 \r
  97                         XmlSchemaUtil.CompileID(Id,this, schema.IDCollection,h);\r
  98 \r
  99                         wildcard.Compile (Namespace, h, schema);\r
 100
 101                         if (processing == XmlSchemaContentProcessing.None)\r
 102                                 wildcard.ResolvedProcessing = XmlSchemaContentProcessing.Strict;\r
 103                         else\r
 104                                 wildcard.ResolvedProcessing = processing;\r
 105 \r
 106                         this.CompilationId = schema.CompilationId;\r
 107                         return errorCount;\r
 108                 }\r
 109                 \r
 110                 internal override int Validate(ValidationEventHandler h, XmlSchema schema)\r
 111                 {\r
 112                         return errorCount;\r
 113                 }\r
 114 \r
 115                 // 3.10.6 Wildcard Subset\r
 116                 internal void ValidateWildcardSubset (XmlSchemaAnyAttribute other,\r
 117                         ValidationEventHandler h, XmlSchema schema)\r
 118                 {\r
 119                         wildcard.ValidateWildcardSubset (other.wildcard, h, schema);\r
 120 \r
 121                 }\r
 122 \r
 123                 internal bool ValidateWildcardAllowsNamespaceName (string ns, XmlSchema schema)\r
 124                 {\r
 125                         return wildcard.ValidateWildcardAllowsNamespaceName (ns, null, schema, false);\r
 126                 }\r
 127 \r
 128                 //<anyAttribute\r
 129                 //  id = ID\r
 130                 //  namespace = ((##any | ##other) | List of (anyURI | (##targetNamespace | ##local)) )  : ##any\r
 131                 //  processContents = (lax | skip | strict) : strict\r
 132                 //  {any attributes with non-schema namespace . . .}>\r
 133                 //  Content: (annotation?)\r
 134                 //</anyAttribute>\r
 135                 internal static XmlSchemaAnyAttribute Read(XmlSchemaReader reader, ValidationEventHandler h)\r
 136                 {\r
 137                         XmlSchemaAnyAttribute any = new XmlSchemaAnyAttribute();\r
 138                         reader.MoveToElement();\r
 139 \r
 140                         if(reader.NamespaceURI != XmlSchema.Namespace || reader.LocalName != xmlname)\r
 141                         {\r
 142                                 error(h,"Should not happen :1: XmlSchemaAnyAttribute.Read, name="+reader.Name,null);\r
 143                                 reader.SkipToEnd();\r
 144                                 return null;\r
 145                         }\r
 146 \r
 147                         any.LineNumber = reader.LineNumber;\r
 148                         any.LinePosition = reader.LinePosition;\r
 149                         any.SourceUri = reader.BaseURI;\r
 150 \r
 151                         while(reader.MoveToNextAttribute())\r
 152                         {\r
 153                                 if(reader.Name == "id")\r
 154                                 {\r
 155                                         any.Id = reader.Value;\r
 156                                 }\r
 157                                 else if(reader.Name == "namespace")\r
 158                                 {\r
 159                                         any.nameSpace = reader.Value;\r
 160                                 }\r
 161                                 else if(reader.Name == "processContents")\r
 162                                 {\r
 163                                         Exception innerex;\r
 164                                         any.processing = XmlSchemaUtil.ReadProcessingAttribute(reader,out innerex);\r
 165                                         if(innerex != null)\r
 166                                                 error(h, reader.Value + " is not a valid value for processContents",innerex);\r
 167                                 }\r
 168                                 else if((reader.NamespaceURI == "" && reader.Name != "xmlns") || reader.NamespaceURI == XmlSchema.Namespace)\r
 169                                 {\r
 170                                         error(h,reader.Name + " is not a valid attribute for anyAttribute",null);\r
 171                                 }\r
 172                                 else\r
 173                                 {\r
 174                                         XmlSchemaUtil.ReadUnhandledAttribute(reader,any);\r
 175                                 }\r
 176                         }\r
 177                         \r
 178                         reader.MoveToElement();\r
 179                         if(reader.IsEmptyElement)\r
 180                                 return any;\r
 181 \r
 182                         //  Content: (annotation?)\r
 183                         int level = 1;\r
 184                         while(reader.ReadNextElement())\r
 185                         {\r
 186                                 if(reader.NodeType == XmlNodeType.EndElement)\r
 187                                 {\r
 188                                         if(reader.LocalName != xmlname)\r
 189                                                 error(h,"Should not happen :2: XmlSchemaAnyAttribute.Read, name="+reader.Name,null);\r
 190                                         break;\r
 191                                 }\r
 192                                 if(level <= 1 && reader.LocalName == "annotation")\r
 193                                 {\r
 194                                         level = 2;      //Only one annotation\r
 195                                         XmlSchemaAnnotation annotation = XmlSchemaAnnotation.Read(reader,h);\r
 196                                         if(annotation != null)\r
 197                                                 any.Annotation = annotation;\r
 198                                         continue;\r
 199                                 }\r
 200                                 reader.RaiseInvalidElementError();\r
 201                         }       \r
 202                         return any;\r
 203                 }\r
 204         }\r
 205 }\r