2 // System.Xml.Serialization.XmlSchemaImporter
\r
5 // Tim Coleman (tim@timcoleman.com)
\r
6 // Lluis Sanchez Gual (lluis@ximian.com)
\r
8 // Copyright (C) Tim Coleman, 2002
\r
12 // Permission is hereby granted, free of charge, to any person obtaining
\r
13 // a copy of this software and associated documentation files (the
\r
14 // "Software"), to deal in the Software without restriction, including
\r
15 // without limitation the rights to use, copy, modify, merge, publish,
\r
16 // distribute, sublicense, and/or sell copies of the Software, and to
\r
17 // permit persons to whom the Software is furnished to do so, subject to
\r
18 // the following conditions:
\r
20 // The above copyright notice and this permission notice shall be
\r
21 // included in all copies or substantial portions of the Software.
\r
23 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
\r
24 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
\r
25 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
\r
26 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
\r
27 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
\r
28 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
\r
29 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
\r
34 using System.CodeDom.Compiler;
\r
36 using System.Xml.Schema;
\r
37 using System.Collections;
\r
39 namespace System.Xml.Serialization
\r
41 public class XmlSchemaImporter
\r
49 CodeIdentifiers typeIdentifiers;
\r
50 CodeIdentifiers elemIdentifiers = new CodeIdentifiers ();
\r
51 Hashtable mappedTypes = new Hashtable ();
\r
52 Hashtable dataMappedTypes = new Hashtable ();
\r
53 Queue pendingMaps = new Queue ();
\r
54 Hashtable sharedAnonymousTypes = new Hashtable ();
\r
55 bool encodedFormat = false;
\r
56 XmlReflectionImporter auxXmlRefImporter;
\r
57 SoapReflectionImporter auxSoapRefImporter;
\r
58 bool anyTypeImported;
\r
61 CodeGenerationOptions options;
\r
64 static readonly XmlQualifiedName anyType = new XmlQualifiedName ("anyType",XmlSchema.Namespace);
\r
65 static readonly XmlQualifiedName arrayType = new XmlQualifiedName ("Array",XmlSerializer.EncodingNamespace);
\r
66 static readonly XmlQualifiedName arrayTypeRefName = new XmlQualifiedName ("arrayType",XmlSerializer.EncodingNamespace);
\r
68 const string XmlNamespace = "http://www.w3.org/XML/1998/namespace";
\r
70 XmlSchemaElement anyElement = null;
\r
74 public XmlTypeMapping Map;
\r
75 public XmlSchemaComplexType SchemaType;
\r
76 public XmlQualifiedName TypeName;
\r
81 #region Constructors
\r
83 public XmlSchemaImporter (XmlSchemas schemas)
\r
85 this.schemas = schemas;
\r
86 typeIdentifiers = new CodeIdentifiers ();
\r
89 public XmlSchemaImporter (XmlSchemas schemas, CodeIdentifiers typeIdentifiers)
\r
92 this.typeIdentifiers = typeIdentifiers;
\r
98 public XmlSchemaImporter (XmlSchemas schemas, CodeGenerationOptions options, CodeDomProvider codeProvider, ImportContext context)
\r
100 this.schemas = schemas;
\r
101 this.options = options;
\r
102 if (context != null) {
\r
103 typeIdentifiers = context.TypeIdentifiers;
\r
104 InitSharedData (context);
\r
107 typeIdentifiers = new CodeIdentifiers ();
\r
111 public XmlSchemaImporter (XmlSchemas schemas, CodeGenerationOptions options, ImportContext context)
\r
113 this.schemas = schemas;
\r
114 this.options = options;
\r
115 if (context != null) {
\r
116 typeIdentifiers = context.TypeIdentifiers;
\r
117 InitSharedData (context);
\r
120 typeIdentifiers = new CodeIdentifiers ();
\r
124 public XmlSchemaImporter (XmlSchemas schemas, CodeIdentifiers typeIdentifiers, CodeGenerationOptions options)
\r
126 this.typeIdentifiers = typeIdentifiers;
\r
127 this.schemas = schemas;
\r
128 this.options = options;
\r
131 void InitSharedData (ImportContext context)
\r
133 if (context.ShareTypes) {
\r
134 mappedTypes = context.MappedTypes;
\r
135 dataMappedTypes = context.DataMappedTypes;
\r
136 sharedAnonymousTypes = context.SharedAnonymousTypes;
\r
141 internal bool UseEncodedFormat
\r
143 get { return encodedFormat; }
\r
144 set { encodedFormat = value; }
\r
147 #endregion // Constructors
\r
151 public XmlMembersMapping ImportAnyType (XmlQualifiedName typeName, string elementName)
\r
153 if (typeName == XmlQualifiedName.Empty)
\r
155 XmlTypeMapMemberAnyElement mapMem = new XmlTypeMapMemberAnyElement ();
\r
156 mapMem.Name = typeName.Name;
\r
157 mapMem.TypeData = TypeTranslator.GetTypeData(typeof(XmlNode));
\r
158 mapMem.ElementInfo.Add (CreateElementInfo (typeName.Namespace, mapMem, typeName.Name, mapMem.TypeData, true, XmlSchemaForm.None));
\r
160 XmlMemberMapping[] mm = new XmlMemberMapping [1];
\r
161 mm[0] = new XmlMemberMapping (typeName.Name, typeName.Namespace, mapMem, encodedFormat);
\r
162 return new XmlMembersMapping (mm);
\r
166 XmlSchemaComplexType stype = (XmlSchemaComplexType) schemas.Find (typeName, typeof (XmlSchemaComplexType));
\r
167 if (stype == null)
\r
168 throw new InvalidOperationException ("Referenced type '" + typeName + "' not found");
\r
170 if (!CanBeAnyElement (stype))
\r
171 throw new InvalidOperationException ("The type '" + typeName + "' is not valid for a collection of any elements");
\r
173 ClassMap cmap = new ClassMap ();
\r
174 CodeIdentifiers classIds = new CodeIdentifiers ();
\r
175 bool isMixed = stype.IsMixed;
\r
176 ImportSequenceContent (typeName, cmap, ((XmlSchemaSequence) stype.Particle).Items, classIds, false, ref isMixed);
\r
177 XmlTypeMapMemberAnyElement mapMem = (XmlTypeMapMemberAnyElement) cmap.AllMembers[0];
\r
178 mapMem.Name = typeName.Name;
\r
180 XmlMemberMapping[] mm = new XmlMemberMapping [1];
\r
181 mm[0] = new XmlMemberMapping (typeName.Name, typeName.Namespace, mapMem, encodedFormat);
\r
182 return new XmlMembersMapping (mm);
\r
186 public XmlTypeMapping ImportDerivedTypeMapping (XmlQualifiedName name, Type baseType)
\r
188 return ImportDerivedTypeMapping (name, baseType, true);
\r
191 public XmlTypeMapping ImportDerivedTypeMapping (XmlQualifiedName name, Type baseType, bool baseTypeCanBeIndirect)
\r
193 XmlQualifiedName qname;
\r
194 XmlSchemaType stype;
\r
199 stype = schemas.Find (name, typeof (XmlSchemaComplexType)) as XmlSchemaComplexType;
\r
200 if (stype == null) throw new InvalidOperationException ("Schema type '" + name + "' not found or not valid");
\r
204 if (!LocateElement (name, out qname, out stype))
\r
208 XmlTypeMapping map = GetRegisteredTypeMapping (qname);
\r
211 // If the type has already been imported, make sure that the map
\r
212 // has the requested base type
\r
214 SetMapBaseType (map, baseType);
\r
215 map.UpdateRoot (name);
\r
219 map = CreateTypeMapping (qname, SchemaTypes.Class, name);
\r
220 if (stype != null) {
\r
221 map.Documentation = GetDocumentation (stype);
\r
222 RegisterMapFixup (map, qname, (XmlSchemaComplexType)stype);
\r
224 ClassMap cmap = new ClassMap ();
\r
225 CodeIdentifiers classIds = new CodeIdentifiers ();
\r
226 map.ObjectMap = cmap;
\r
227 AddTextMember (qname, cmap, classIds);
\r
230 BuildPendingMaps ();
\r
231 SetMapBaseType (map, baseType);
\r
236 void SetMapBaseType (XmlTypeMapping map, Type baseType)
\r
238 // This method sets the base type for a given map.
\r
239 // If the map already inherits from this type, it does nothing.
\r
241 // Fiirst of all, check if the map already inherits from baseType
\r
243 XmlTypeMapping topMap = null;
\r
244 while (map != null)
\r
246 if (map.TypeData.Type == baseType)
\r
252 // Does not have the requested base type.
\r
253 // Then, get/create a map for that base type.
\r
255 XmlTypeMapping baseMap = ReflectType (baseType);
\r
257 // Add this map as a derived map of the base map
\r
259 topMap.BaseMap = baseMap;
\r
260 baseMap.DerivedTypes.Add (topMap);
\r
261 baseMap.DerivedTypes.AddRange (topMap.DerivedTypes);
\r
263 // Now add the base type fields to all derived maps
\r
265 ClassMap baseClassMap = (ClassMap)baseMap.ObjectMap;
\r
267 ClassMap cmap = (ClassMap)topMap.ObjectMap;
\r
268 foreach (XmlTypeMapMember member in baseClassMap.AllMembers)
\r
269 cmap.AddMember (member);
\r
271 foreach (XmlTypeMapping derivedMap in topMap.DerivedTypes)
\r
273 cmap = (ClassMap)derivedMap.ObjectMap;
\r
274 foreach (XmlTypeMapMember member in baseClassMap.AllMembers)
\r
275 cmap.AddMember (member);
\r
279 public XmlMembersMapping ImportMembersMapping (XmlQualifiedName name)
\r
281 XmlSchemaElement elem = (XmlSchemaElement) schemas.Find (name, typeof (XmlSchemaElement));
\r
282 if (elem == null) throw new InvalidOperationException ("Schema element '" + name + "' not found or not valid");
\r
284 XmlSchemaComplexType stype;
\r
285 if (elem.SchemaType != null)
\r
287 stype = elem.SchemaType as XmlSchemaComplexType;
\r
291 if (elem.SchemaTypeName.IsEmpty) return null;
\r
292 object type = schemas.Find (elem.SchemaTypeName, typeof (XmlSchemaComplexType));
\r
293 if (type == null) {
\r
294 if (IsPrimitiveTypeNamespace (elem.SchemaTypeName.Namespace)) return null;
\r
295 throw new InvalidOperationException ("Schema type '" + elem.SchemaTypeName + "' not found");
\r
297 stype = type as XmlSchemaComplexType;
\r
300 if (stype == null)
\r
301 throw new InvalidOperationException ("Schema element '" + name + "' not found or not valid");
\r
303 XmlMemberMapping[] mapping = ImportMembersMappingComposite (stype, name);
\r
304 return new XmlMembersMapping (name.Name, name.Namespace, mapping);
\r
307 public XmlMembersMapping ImportMembersMapping (XmlQualifiedName[] names)
\r
309 XmlMemberMapping[] mapping = new XmlMemberMapping [names.Length];
\r
310 for (int n=0; n<names.Length; n++)
\r
312 XmlSchemaElement elem = (XmlSchemaElement) schemas.Find (names[n], typeof (XmlSchemaElement));
\r
313 if (elem == null) throw new InvalidOperationException ("Schema element '" + names[n] + "' not found");
\r
315 XmlQualifiedName typeQName = new XmlQualifiedName ("Message", names[n].Namespace);
\r
316 XmlTypeMapping tmap;
\r
317 TypeData td = GetElementTypeData (typeQName, elem, names[n], out tmap);
\r
319 mapping[n] = ImportMemberMapping (elem.Name, typeQName.Namespace, elem.IsNillable, td, tmap);
\r
321 BuildPendingMaps ();
\r
322 return new XmlMembersMapping (mapping);
\r
327 public XmlMembersMapping ImportMembersMapping (string name, string ns, SoapSchemaMember[] members)
\r
329 throw new NotImplementedException ();
\r
333 public XmlTypeMapping ImportSchemaType (XmlQualifiedName typeName)
\r
335 throw new NotImplementedException ();
\r
339 public XmlTypeMapping ImportSchemaType (XmlQualifiedName typeName, Type baseType)
\r
341 throw new NotImplementedException ();
\r
345 public XmlTypeMapping ImportSchemaType (XmlQualifiedName typeName, Type baseType, bool baseTypeCanBeIndirect)
\r
347 throw new NotImplementedException ();
\r
351 internal XmlMembersMapping ImportEncodedMembersMapping (string name, string ns, SoapSchemaMember[] members, bool hasWrapperElement)
\r
353 XmlMemberMapping[] mapping = new XmlMemberMapping [members.Length];
\r
354 for (int n=0; n<members.Length; n++)
\r
356 TypeData td = GetTypeData (members[n].MemberType, null);
\r
357 XmlTypeMapping tmap = GetTypeMapping (td);
\r
358 mapping[n] = ImportMemberMapping (members[n].MemberName, members[n].MemberType.Namespace, true, td, tmap);
\r
360 BuildPendingMaps ();
\r
361 return new XmlMembersMapping (name, ns, hasWrapperElement, false, mapping);
\r
364 internal XmlMembersMapping ImportEncodedMembersMapping (string name, string ns, SoapSchemaMember member)
\r
366 XmlSchemaComplexType stype = schemas.Find (member.MemberType, typeof (XmlSchemaComplexType)) as XmlSchemaComplexType;
\r
367 if (stype == null) throw new InvalidOperationException ("Schema type '" + member.MemberType + "' not found or not valid");
\r
369 XmlMemberMapping[] mapping = ImportMembersMappingComposite (stype, member.MemberType);
\r
370 return new XmlMembersMapping (name, ns, mapping);
\r
373 XmlMemberMapping[] ImportMembersMappingComposite (XmlSchemaComplexType stype, XmlQualifiedName refer)
\r
375 if (stype.Particle == null)
\r
376 return new XmlMemberMapping [0];
\r
378 ClassMap cmap = new ClassMap ();
\r
380 XmlSchemaSequence seq = stype.Particle as XmlSchemaSequence;
\r
381 if (seq == null) throw new InvalidOperationException ("Schema element '" + refer + "' cannot be imported as XmlMembersMapping");
\r
383 CodeIdentifiers classIds = new CodeIdentifiers ();
\r
384 ImportParticleComplexContent (refer, cmap, seq, classIds, false);
\r
385 ImportAttributes (refer, cmap, stype.Attributes, stype.AnyAttribute, classIds);
\r
387 BuildPendingMaps ();
\r
390 XmlMemberMapping[] mapping = new XmlMemberMapping [cmap.AllMembers.Count];
\r
391 foreach (XmlTypeMapMember mapMem in cmap.AllMembers)
\r
392 mapping[n++] = new XmlMemberMapping (mapMem.Name, refer.Namespace, mapMem, encodedFormat);
\r
397 XmlMemberMapping ImportMemberMapping (string name, string ns, bool isNullable, TypeData type, XmlTypeMapping emap)
\r
399 XmlTypeMapMemberElement mapMem;
\r
401 if (type.IsListType)
\r
402 mapMem = new XmlTypeMapMemberList ();
\r
404 mapMem = new XmlTypeMapMemberElement ();
\r
406 mapMem.Name = name;
\r
407 mapMem.TypeData = type;
\r
408 mapMem.ElementInfo.Add (CreateElementInfo (ns, mapMem, name, type, isNullable, XmlSchemaForm.None, emap));
\r
409 return new XmlMemberMapping (name, ns, mapMem, encodedFormat);
\r
413 public XmlMembersMapping ImportMembersMapping (XmlQualifiedName[] names, Type baseType, bool baseTypeCanBeIndirect)
\r
415 throw new NotImplementedException ();
\r
418 public XmlTypeMapping ImportTypeMapping (XmlQualifiedName name)
\r
420 XmlQualifiedName qname;
\r
421 XmlSchemaType stype;
\r
423 XmlSchemaElement elem = (XmlSchemaElement) schemas.Find (name, typeof (XmlSchemaElement));
\r
424 if (!LocateElement (elem, out qname, out stype)) return null;
\r
426 if (stype == null) {
\r
427 // Importing a primitive type
\r
428 TypeData td = TypeTranslator.GetPrimitiveTypeData (qname.Name);
\r
429 return ReflectType (td, name.Namespace);
\r
432 XmlTypeMapping map = GetRegisteredTypeMapping (qname);
\r
433 if (map != null) return map;
\r
435 map = CreateTypeMapping (qname, SchemaTypes.Class, name);
\r
436 map.Documentation = GetDocumentation (stype);
\r
437 map.IsNullable = elem.IsNillable;
\r
438 RegisterMapFixup (map, qname, (XmlSchemaComplexType)stype);
\r
440 BuildPendingMaps ();
\r
444 bool LocateElement (XmlQualifiedName name, out XmlQualifiedName qname, out XmlSchemaType stype)
\r
446 XmlSchemaElement elem = (XmlSchemaElement) schemas.Find (name, typeof (XmlSchemaElement));
\r
447 return LocateElement (elem, out qname, out stype);
\r
450 bool LocateElement (XmlSchemaElement elem, out XmlQualifiedName qname, out XmlSchemaType stype)
\r
455 if (elem == null) return false;
\r
457 // The root element must be an element with complex type
\r
459 if (elem.SchemaType != null)
\r
461 stype = elem.SchemaType;
\r
462 qname = elem.QualifiedName;
\r
466 if (elem.SchemaTypeName.IsEmpty) return false;
\r
468 object type = schemas.Find (elem.SchemaTypeName, typeof (XmlSchemaComplexType));
\r
469 if (type == null) type = schemas.Find (elem.SchemaTypeName, typeof (XmlSchemaSimpleType));
\r
470 if (type == null) {
\r
471 if (IsPrimitiveTypeNamespace (elem.SchemaTypeName.Namespace)) {
\r
472 qname = elem.SchemaTypeName;
\r
475 throw new InvalidOperationException ("Schema type '" + elem.SchemaTypeName + "' not found");
\r
477 stype = (XmlSchemaType) type;
\r
478 qname = stype.QualifiedName;
\r
480 XmlSchemaType btype = stype.BaseSchemaType as XmlSchemaType;
\r
481 if (btype != null && btype.QualifiedName == elem.SchemaTypeName)
\r
482 throw new InvalidOperationException ("Cannot import schema for type '" + elem.SchemaTypeName.Name + "' from namespace '" + elem.SchemaTypeName.Namespace + "'. Redefine not supported");
\r
485 if (stype is XmlSchemaSimpleType) return false;
\r
489 XmlTypeMapping ImportType (XmlQualifiedName name, XmlQualifiedName root, bool throwOnError)
\r
491 XmlTypeMapping map = GetRegisteredTypeMapping (name);
\r
493 map.UpdateRoot (root);
\r
497 XmlSchemaType type = (XmlSchemaType) schemas.Find (name, typeof (XmlSchemaComplexType));
\r
498 if (type == null) type = (XmlSchemaType) schemas.Find (name, typeof (XmlSchemaSimpleType));
\r
502 if (throwOnError) {
\r
503 if (name.Namespace == XmlSerializer.EncodingNamespace)
\r
504 throw new InvalidOperationException ("Referenced type '" + name + "' valid only for encoded SOAP.");
\r
506 throw new InvalidOperationException ("Referenced type '" + name + "' not found.");
\r
511 return ImportType (name, type, root);
\r
514 XmlTypeMapping ImportClass (XmlQualifiedName name)
\r
516 XmlTypeMapping map = ImportType (name, null, true);
\r
517 if (map.TypeData.SchemaType == SchemaTypes.Class) return map;
\r
518 XmlSchemaComplexType stype = schemas.Find (name, typeof (XmlSchemaComplexType)) as XmlSchemaComplexType;
\r
519 return CreateClassMap (name, stype, new XmlQualifiedName (map.ElementName, map.Namespace));
\r
522 XmlTypeMapping ImportType (XmlQualifiedName name, XmlSchemaType stype, XmlQualifiedName root)
\r
524 XmlTypeMapping map = GetRegisteredTypeMapping (name);
\r
526 XmlSchemaComplexType ct = stype as XmlSchemaComplexType;
\r
527 if (map.TypeData.SchemaType != SchemaTypes.Class || ct == null || !CanBeArray (name, ct)) {
\r
528 map.UpdateRoot (root);
\r
532 // The map was initially imported as a class, but it turns out that it is an
\r
533 // array. It has to be imported now as array.
\r
536 if (stype is XmlSchemaComplexType)
\r
537 return ImportClassComplexType (name, (XmlSchemaComplexType) stype, root);
\r
538 else if (stype is XmlSchemaSimpleType)
\r
539 return ImportClassSimpleType (name, (XmlSchemaSimpleType) stype, root);
\r
541 throw new NotSupportedException ("Schema type not supported: " + stype.GetType ());
\r
544 XmlTypeMapping ImportClassComplexType (XmlQualifiedName typeQName, XmlSchemaComplexType stype, XmlQualifiedName root)
\r
546 // The need for fixups: If the complex type is an array, then to get the type of the
\r
547 // array we need first to get the type of the items of the array.
\r
548 // But if one of the item types or its children has a referece to this type array,
\r
549 // then we enter in an infinite loop. This does not happen with class types because
\r
550 // the class map is registered before parsing the children. We can't do the same
\r
551 // with the array type because to register the array map we need the type of the array.
\r
553 Type anyType = GetAnyElementType (stype);
\r
554 if (anyType != null)
\r
555 return GetTypeMapping (TypeTranslator.GetTypeData(anyType));
\r
557 if (CanBeArray (typeQName, stype))
\r
560 ListMap listMap = BuildArrayMap (typeQName, stype, out typeData);
\r
561 if (listMap != null)
\r
563 XmlTypeMapping map = CreateArrayTypeMapping (typeQName, typeData);
\r
564 map.ObjectMap = listMap;
\r
568 // After all, it is not an array. Create a class map then.
\r
570 else if (CanBeIXmlSerializable (stype))
\r
572 return ImportXmlSerializableMapping (typeQName.Namespace);
\r
575 // Register the map right now but do not build it,
\r
576 // This will avoid loops.
\r
578 return CreateClassMap (typeQName, stype, root);
\r
581 XmlTypeMapping CreateClassMap (XmlQualifiedName typeQName, XmlSchemaComplexType stype, XmlQualifiedName root)
\r
583 XmlTypeMapping map = CreateTypeMapping (typeQName, SchemaTypes.Class, root);
\r
584 map.Documentation = GetDocumentation (stype);
\r
585 RegisterMapFixup (map, typeQName, stype);
\r
589 void RegisterMapFixup (XmlTypeMapping map, XmlQualifiedName typeQName, XmlSchemaComplexType stype)
\r
591 MapFixup fixup = new MapFixup ();
\r
593 fixup.SchemaType = stype;
\r
594 fixup.TypeName = typeQName;
\r
595 pendingMaps.Enqueue (fixup);
\r
598 void BuildPendingMaps ()
\r
600 while (pendingMaps.Count > 0) {
\r
601 MapFixup fixup = (MapFixup) pendingMaps.Dequeue ();
\r
602 if (fixup.Map.ObjectMap == null) {
\r
603 BuildClassMap (fixup.Map, fixup.TypeName, fixup.SchemaType);
\r
604 if (fixup.Map.ObjectMap == null) pendingMaps.Enqueue (fixup);
\r
609 void BuildPendingMap (XmlTypeMapping map)
\r
611 if (map.ObjectMap != null) return;
\r
613 foreach (MapFixup fixup in pendingMaps)
\r
615 if (fixup.Map == map) {
\r
616 BuildClassMap (fixup.Map, fixup.TypeName, fixup.SchemaType);
\r
620 throw new InvalidOperationException ("Can't complete map of type " + map.XmlType + " : " + map.Namespace);
\r
623 void BuildClassMap (XmlTypeMapping map, XmlQualifiedName typeQName, XmlSchemaComplexType stype)
\r
625 CodeIdentifiers classIds = new CodeIdentifiers();
\r
626 classIds.AddReserved (map.TypeData.TypeName);
\r
628 ClassMap cmap = new ClassMap ();
\r
629 map.ObjectMap = cmap;
\r
630 bool isMixed = stype.IsMixed;
\r
632 if (stype.Particle != null)
\r
633 ImportParticleComplexContent (typeQName, cmap, stype.Particle, classIds, isMixed);
\r
636 if (stype.ContentModel is XmlSchemaSimpleContent) {
\r
637 ImportSimpleContent (typeQName, map, (XmlSchemaSimpleContent)stype.ContentModel, classIds, isMixed);
\r
639 else if (stype.ContentModel is XmlSchemaComplexContent) {
\r
640 ImportComplexContent (typeQName, map, (XmlSchemaComplexContent)stype.ContentModel, classIds, isMixed);
\r
644 ImportAttributes (typeQName, cmap, stype.Attributes, stype.AnyAttribute, classIds);
\r
645 ImportExtensionTypes (typeQName);
\r
647 if (isMixed) AddTextMember (typeQName, cmap, classIds);
\r
649 AddObjectDerivedMap (map);
\r
652 void ImportAttributes (XmlQualifiedName typeQName, ClassMap cmap, XmlSchemaObjectCollection atts, XmlSchemaAnyAttribute anyat, CodeIdentifiers classIds)
\r
656 XmlTypeMapMemberAnyAttribute member = new XmlTypeMapMemberAnyAttribute ();
\r
657 member.Name = classIds.AddUnique ("AnyAttribute", member);
\r
658 member.TypeData = TypeTranslator.GetTypeData (typeof(XmlAttribute[]));
\r
659 cmap.AddMember (member);
\r
662 foreach (XmlSchemaObject at in atts)
\r
664 if (at is XmlSchemaAttribute)
\r
667 XmlSchemaAttribute attr = (XmlSchemaAttribute)at;
\r
668 XmlSchemaAttribute refAttr = GetRefAttribute (typeQName, attr, out ns);
\r
669 XmlTypeMapMemberAttribute member = new XmlTypeMapMemberAttribute ();
\r
670 member.Name = classIds.AddUnique (CodeIdentifier.MakeValid (refAttr.Name), member);
\r
671 member.Documentation = GetDocumentation (attr);
\r
672 member.AttributeName = refAttr.Name;
\r
673 member.Namespace = ns;
\r
674 member.Form = refAttr.Form;
\r
675 member.TypeData = GetAttributeTypeData (typeQName, attr);
\r
677 if (refAttr.DefaultValue != null)
\r
678 member.DefaultValue = ImportDefaultValue (member.TypeData, refAttr.DefaultValue);
\r
679 else if (member.TypeData.IsValueType)
\r
680 member.IsOptionalValueType = (refAttr.ValidatedUse != XmlSchemaUse.Required);
\r
682 if (member.TypeData.IsComplexType)
\r
683 member.MappedType = GetTypeMapping (member.TypeData);
\r
684 cmap.AddMember (member);
\r
686 else if (at is XmlSchemaAttributeGroupRef)
\r
688 XmlSchemaAttributeGroupRef gref = (XmlSchemaAttributeGroupRef)at;
\r
689 XmlSchemaAttributeGroup grp = FindRefAttributeGroup (gref.RefName);
\r
690 ImportAttributes (typeQName, cmap, grp.Attributes, grp.AnyAttribute, classIds);
\r
695 ListMap BuildArrayMap (XmlQualifiedName typeQName, XmlSchemaComplexType stype, out TypeData arrayTypeData)
\r
699 XmlSchemaComplexContent content = stype.ContentModel as XmlSchemaComplexContent;
\r
700 XmlSchemaComplexContentRestriction rest = content.Content as XmlSchemaComplexContentRestriction;
\r
701 XmlSchemaAttribute arrayTypeAt = FindArrayAttribute (rest.Attributes);
\r
703 if (arrayTypeAt != null)
\r
705 XmlAttribute[] uatts = arrayTypeAt.UnhandledAttributes;
\r
706 if (uatts == null || uatts.Length == 0) throw new InvalidOperationException ("arrayType attribute not specified in array declaration: " + typeQName);
\r
708 XmlAttribute xat = null;
\r
709 foreach (XmlAttribute at in uatts)
\r
710 if (at.LocalName == "arrayType" && at.NamespaceURI == XmlSerializer.WsdlNamespace)
\r
711 { xat = at; break; }
\r
714 throw new InvalidOperationException ("arrayType attribute not specified in array declaration: " + typeQName);
\r
716 string name, ns, dims;
\r
717 TypeTranslator.ParseArrayType (xat.Value, out name, out ns, out dims);
\r
718 return BuildEncodedArrayMap (name + dims, ns, out arrayTypeData);
\r
722 XmlSchemaElement elem = null;
\r
723 XmlSchemaSequence seq = rest.Particle as XmlSchemaSequence;
\r
724 if (seq != null && seq.Items.Count == 1)
\r
725 elem = seq.Items[0] as XmlSchemaElement;
\r
727 XmlSchemaAll all = rest.Particle as XmlSchemaAll;
\r
728 if (all != null && all.Items.Count == 1)
\r
729 elem = all.Items[0] as XmlSchemaElement;
\r
732 throw new InvalidOperationException ("Unknown array format");
\r
734 return BuildEncodedArrayMap (elem.SchemaTypeName.Name + "[]", elem.SchemaTypeName.Namespace, out arrayTypeData);
\r
739 ClassMap cmap = new ClassMap ();
\r
740 CodeIdentifiers classIds = new CodeIdentifiers();
\r
741 ImportParticleComplexContent (typeQName, cmap, stype.Particle, classIds, stype.IsMixed);
\r
743 XmlTypeMapMemberFlatList list = (cmap.AllMembers.Count == 1) ? cmap.AllMembers[0] as XmlTypeMapMemberFlatList : null;
\r
744 if (list != null && list.ChoiceMember == null)
\r
746 arrayTypeData = list.TypeData;
\r
747 return list.ListMap;
\r
751 arrayTypeData = null;
\r
757 ListMap BuildEncodedArrayMap (string type, string ns, out TypeData arrayTypeData)
\r
759 ListMap map = new ListMap ();
\r
761 int i = type.LastIndexOf ("[");
\r
762 if (i == -1) throw new InvalidOperationException ("Invalid arrayType value: " + type);
\r
763 if (type.IndexOf (",",i) != -1) throw new InvalidOperationException ("Multidimensional arrays are not supported");
\r
765 string itemType = type.Substring (0,i);
\r
767 TypeData itemTypeData;
\r
768 if (itemType.IndexOf ("[") != -1)
\r
770 ListMap innerListMap = BuildEncodedArrayMap (itemType, ns, out itemTypeData);
\r
772 int dims = itemType.Split ('[').Length - 1;
\r
773 string name = TypeTranslator.GetArrayName (type, dims);
\r
774 XmlQualifiedName qname = new XmlQualifiedName (name, ns);
\r
775 XmlTypeMapping tmap = CreateArrayTypeMapping (qname, itemTypeData);
\r
776 tmap.ObjectMap = innerListMap;
\r
780 itemTypeData = GetTypeData (new XmlQualifiedName (itemType, ns), null);
\r
783 arrayTypeData = itemTypeData.ListTypeData;
\r
785 map.ItemInfo = new XmlTypeMapElementInfoList();
\r
786 map.ItemInfo.Add (CreateElementInfo ("", null, "Item", itemTypeData, true, XmlSchemaForm.None));
\r
790 XmlSchemaAttribute FindArrayAttribute (XmlSchemaObjectCollection atts)
\r
792 foreach (object ob in atts)
\r
794 XmlSchemaAttribute att = ob as XmlSchemaAttribute;
\r
795 if (att != null && att.RefName == arrayTypeRefName) return att;
\r
797 XmlSchemaAttributeGroupRef gref = ob as XmlSchemaAttributeGroupRef;
\r
800 XmlSchemaAttributeGroup grp = FindRefAttributeGroup (gref.RefName);
\r
801 att = FindArrayAttribute (grp.Attributes);
\r
802 if (att != null) return att;
\r
808 void ImportParticleComplexContent (XmlQualifiedName typeQName, ClassMap cmap, XmlSchemaParticle particle, CodeIdentifiers classIds, bool isMixed)
\r
810 ImportParticleContent (typeQName, cmap, particle, classIds, false, ref isMixed);
\r
811 if (isMixed) AddTextMember (typeQName, cmap, classIds);
\r
814 void AddTextMember (XmlQualifiedName typeQName, ClassMap cmap, CodeIdentifiers classIds)
\r
816 if (cmap.XmlTextCollector == null)
\r
818 XmlTypeMapMemberFlatList member = new XmlTypeMapMemberFlatList ();
\r
819 member.Name = classIds.AddUnique ("Text", member);
\r
820 member.TypeData = TypeTranslator.GetTypeData (typeof(string[]));
\r
821 member.ElementInfo.Add (CreateTextElementInfo (typeQName.Namespace, member, member.TypeData.ListItemTypeData));
\r
822 member.IsXmlTextCollector = true;
\r
823 member.ListMap = new ListMap ();
\r
824 member.ListMap.ItemInfo = member.ElementInfo;
\r
825 cmap.AddMember (member);
\r
829 void ImportParticleContent (XmlQualifiedName typeQName, ClassMap cmap, XmlSchemaParticle particle, CodeIdentifiers classIds, bool multiValue, ref bool isMixed)
\r
831 if (particle == null) return;
\r
833 if (particle is XmlSchemaGroupRef)
\r
834 particle = GetRefGroupParticle ((XmlSchemaGroupRef)particle);
\r
836 if (particle.MaxOccurs > 1) multiValue = true;
\r
838 if (particle is XmlSchemaSequence) {
\r
839 ImportSequenceContent (typeQName, cmap, ((XmlSchemaSequence)particle).Items, classIds, multiValue, ref isMixed);
\r
841 else if (particle is XmlSchemaChoice) {
\r
842 if (((XmlSchemaChoice)particle).Items.Count == 1)
\r
843 ImportSequenceContent (typeQName, cmap, ((XmlSchemaChoice)particle).Items, classIds, multiValue, ref isMixed);
\r
845 ImportChoiceContent (typeQName, cmap, (XmlSchemaChoice)particle, classIds, multiValue);
\r
847 else if (particle is XmlSchemaAll) {
\r
848 ImportSequenceContent (typeQName, cmap, ((XmlSchemaAll)particle).Items, classIds, multiValue, ref isMixed);
\r
852 void ImportSequenceContent (XmlQualifiedName typeQName, ClassMap cmap, XmlSchemaObjectCollection items, CodeIdentifiers classIds, bool multiValue, ref bool isMixed)
\r
854 foreach (XmlSchemaObject item in items)
\r
856 if (item is XmlSchemaElement)
\r
859 XmlSchemaElement elem = (XmlSchemaElement) item;
\r
860 XmlTypeMapping emap;
\r
861 TypeData typeData = GetElementTypeData (typeQName, elem, null, out emap);
\r
862 XmlSchemaElement refElem = GetRefElement (typeQName, elem, out ns);
\r
864 if (elem.MaxOccurs == 1 && !multiValue)
\r
866 XmlTypeMapMemberElement member = null;
\r
867 if (typeData.SchemaType != SchemaTypes.Array)
\r
869 member = new XmlTypeMapMemberElement ();
\r
870 if (refElem.DefaultValue != null) member.DefaultValue = ImportDefaultValue (typeData, refElem.DefaultValue);
\r
872 else if (GetTypeMapping (typeData).IsSimpleType)
\r
874 // It is a simple list (space separated list).
\r
875 // Since this is not supported, map as a single item value
\r
876 member = new XmlTypeMapMemberElement ();
\r
878 // In MS.NET those types are mapped to a string
\r
879 typeData = TypeTranslator.GetTypeData(typeof(string));
\r
881 typeData = typeData.ListItemTypeData;
\r
885 member = new XmlTypeMapMemberList ();
\r
887 if (elem.MinOccurs == 0 && typeData.IsValueType)
\r
888 member.IsOptionalValueType = true;
\r
890 member.Name = classIds.AddUnique(CodeIdentifier.MakeValid(refElem.Name), member);
\r
891 member.Documentation = GetDocumentation (elem);
\r
892 member.TypeData = typeData;
\r
893 member.ElementInfo.Add (CreateElementInfo (ns, member, refElem.Name, typeData, refElem.IsNillable, refElem.Form, emap));
\r
894 cmap.AddMember (member);
\r
898 XmlTypeMapMemberFlatList member = new XmlTypeMapMemberFlatList ();
\r
899 member.ListMap = new ListMap ();
\r
900 member.Name = classIds.AddUnique(CodeIdentifier.MakeValid(refElem.Name), member);
\r
901 member.Documentation = GetDocumentation (elem);
\r
902 member.TypeData = typeData.ListTypeData;
\r
903 member.ElementInfo.Add (CreateElementInfo (ns, member, refElem.Name, typeData, refElem.IsNillable, refElem.Form, emap));
\r
904 member.ListMap.ItemInfo = member.ElementInfo;
\r
905 cmap.AddMember (member);
\r
908 else if (item is XmlSchemaAny)
\r
910 XmlSchemaAny elem = (XmlSchemaAny) item;
\r
911 XmlTypeMapMemberAnyElement member = new XmlTypeMapMemberAnyElement ();
\r
912 member.Name = classIds.AddUnique ("Any", member);
\r
913 member.Documentation = GetDocumentation (elem);
\r
916 if (elem.MaxOccurs != 1 || multiValue)
\r
917 ctype = isMixed ? typeof(XmlNode[]) : typeof(XmlElement[]);
\r
919 ctype = isMixed ? typeof(XmlNode) : typeof(XmlElement);
\r
921 member.TypeData = TypeTranslator.GetTypeData (ctype);
\r
922 XmlTypeMapElementInfo einfo = new XmlTypeMapElementInfo (member, member.TypeData);
\r
923 einfo.IsUnnamedAnyElement = true;
\r
924 member.ElementInfo.Add (einfo);
\r
928 einfo = CreateTextElementInfo (typeQName.Namespace, member, member.TypeData);
\r
929 member.ElementInfo.Add (einfo);
\r
930 member.IsXmlTextCollector = true;
\r
931 isMixed = false; //Allow only one XmlTextAttribute
\r
934 cmap.AddMember (member);
\r
936 else if (item is XmlSchemaParticle) {
\r
937 ImportParticleContent (typeQName, cmap, (XmlSchemaParticle)item, classIds, multiValue, ref isMixed);
\r
942 object ImportDefaultValue (TypeData typeData, string value)
\r
944 if (typeData.SchemaType == SchemaTypes.Enum) {
\r
945 XmlTypeMapping map = GetTypeMapping (typeData);
\r
946 EnumMap emap = (EnumMap) map.ObjectMap;
\r
947 string res = emap.GetEnumName (map.TypeFullName, value);
\r
948 if (res == null) throw new InvalidOperationException ("'" + value + "' is not a valid enumeration value");
\r
951 return XmlCustomFormatter.FromXmlString (typeData, value);
\r
954 void ImportChoiceContent (XmlQualifiedName typeQName, ClassMap cmap, XmlSchemaChoice choice, CodeIdentifiers classIds, bool multiValue)
\r
956 XmlTypeMapElementInfoList choices = new XmlTypeMapElementInfoList ();
\r
957 multiValue = ImportChoices (typeQName, null, choices, choice.Items) || multiValue;
\r
958 if (choices.Count == 0) return;
\r
960 if (choice.MaxOccurs > 1) multiValue = true;
\r
962 XmlTypeMapMemberElement member;
\r
965 member = new XmlTypeMapMemberFlatList ();
\r
966 member.Name = classIds.AddUnique ("Items", member);
\r
967 ListMap listMap = new ListMap ();
\r
968 listMap.ItemInfo = choices;
\r
969 ((XmlTypeMapMemberFlatList)member).ListMap = listMap;
\r
973 member = new XmlTypeMapMemberElement ();
\r
974 member.Name = classIds.AddUnique ("Item", member);
\r
977 // If all choices have the same type, use that type for the member.
\r
978 // If not use System.Object.
\r
979 // If there are at least two choices with the same type, use a choice
\r
980 // identifier attribute
\r
982 TypeData typeData = null;
\r
983 bool twoEqual = false;
\r
984 bool allEqual = true;
\r
985 Hashtable types = new Hashtable ();
\r
987 for (int n = choices.Count - 1; n >= 0; n--)
\r
989 XmlTypeMapElementInfo einfo = (XmlTypeMapElementInfo) choices [n];
\r
991 // In some complex schemas, we may end up with several options
\r
992 // with the same name. It is better to ignore the extra options
\r
993 // than to crash. It's the best we can do, and btw it works
\r
994 // better than in MS.NET.
\r
996 if (cmap.GetElement (einfo.ElementName, einfo.Namespace) != null ||
\r
997 choices.IndexOfElement (einfo.ElementName, einfo.Namespace) != n)
\r
999 choices.RemoveAt (n);
\r
1003 if (types.ContainsKey (einfo.TypeData)) twoEqual = true;
\r
1004 else types.Add (einfo.TypeData, einfo);
\r
1006 TypeData choiceType = einfo.TypeData;
\r
1007 if (choiceType.SchemaType == SchemaTypes.Class)
\r
1009 // When comparing class types, use the most generic class in the
\r
1010 // inheritance hierarchy
\r
1012 XmlTypeMapping choiceMap = GetTypeMapping (choiceType);
\r
1013 BuildPendingMap (choiceMap);
\r
1014 while (choiceMap.BaseMap != null) {
\r
1015 choiceMap = choiceMap.BaseMap;
\r
1016 BuildPendingMap (choiceMap);
\r
1017 choiceType = choiceMap.TypeData;
\r
1021 if (typeData == null) typeData = choiceType;
\r
1022 else if (typeData != choiceType) allEqual = false;
\r
1026 typeData = TypeTranslator.GetTypeData (typeof(object));
\r
1030 // Create the choice member
\r
1031 XmlTypeMapMemberElement choiceMember = new XmlTypeMapMemberElement ();
\r
1032 choiceMember.Ignore = true;
\r
1033 choiceMember.Name = classIds.AddUnique (member.Name + "ElementName", choiceMember);
\r
1034 member.ChoiceMember = choiceMember.Name;
\r
1036 // Create the choice enum
\r
1037 XmlTypeMapping enumMap = CreateTypeMapping (new XmlQualifiedName (member.Name + "ChoiceType", typeQName.Namespace), SchemaTypes.Enum, null);
\r
1038 enumMap.IncludeInSchema = false;
\r
1040 CodeIdentifiers codeIdents = new CodeIdentifiers ();
\r
1041 EnumMap.EnumMapMember[] members = new EnumMap.EnumMapMember [choices.Count];
\r
1042 for (int n=0; n<choices.Count; n++)
\r
1044 XmlTypeMapElementInfo it =(XmlTypeMapElementInfo) choices[n];
\r
1045 bool extraNs = (it.Namespace != null && it.Namespace != "" && it.Namespace != typeQName.Namespace);
\r
1046 string xmlName = extraNs ? it.Namespace + ":" + it.ElementName : it.ElementName;
\r
1047 string enumName = codeIdents.AddUnique (CodeIdentifier.MakeValid (it.ElementName), it);
\r
1048 members [n] = new EnumMap.EnumMapMember (xmlName, enumName);
\r
1050 enumMap.ObjectMap = new EnumMap (members, false);
\r
1052 choiceMember.TypeData = multiValue ? enumMap.TypeData.ListTypeData : enumMap.TypeData;
\r
1053 choiceMember.ElementInfo.Add (CreateElementInfo (typeQName.Namespace, choiceMember, choiceMember.Name, choiceMember.TypeData, false, XmlSchemaForm.None));
\r
1054 cmap.AddMember (choiceMember);
\r
1058 typeData = typeData.ListTypeData;
\r
1060 member.ElementInfo = choices;
\r
1061 member.Documentation = GetDocumentation (choice);
\r
1062 member.TypeData = typeData;
\r
1063 cmap.AddMember (member);
\r
1066 bool ImportChoices (XmlQualifiedName typeQName, XmlTypeMapMember member, XmlTypeMapElementInfoList choices, XmlSchemaObjectCollection items)
\r
1068 bool multiValue = false;
\r
1069 foreach (XmlSchemaObject titem in items)
\r
1071 XmlSchemaObject item = titem;
\r
1072 if (item is XmlSchemaGroupRef)
\r
1073 item = GetRefGroupParticle ((XmlSchemaGroupRef)item);
\r
1075 if (item is XmlSchemaElement)
\r
1078 XmlSchemaElement elem = (XmlSchemaElement) item;
\r
1079 XmlTypeMapping emap;
\r
1080 TypeData typeData = GetElementTypeData (typeQName, elem, null, out emap);
\r
1081 XmlSchemaElement refElem = GetRefElement (typeQName, elem, out ns);
\r
1082 choices.Add (CreateElementInfo (ns, member, refElem.Name, typeData, refElem.IsNillable, refElem.Form, emap));
\r
1083 if (elem.MaxOccurs > 1) multiValue = true;
\r
1085 else if (item is XmlSchemaAny)
\r
1087 XmlTypeMapElementInfo einfo = new XmlTypeMapElementInfo (member, TypeTranslator.GetTypeData(typeof(XmlElement)));
\r
1088 einfo.IsUnnamedAnyElement = true;
\r
1089 choices.Add (einfo);
\r
1091 else if (item is XmlSchemaChoice) {
\r
1092 multiValue = ImportChoices (typeQName, member, choices, ((XmlSchemaChoice)item).Items) || multiValue;
\r
1094 else if (item is XmlSchemaSequence) {
\r
1095 multiValue = ImportChoices (typeQName, member, choices, ((XmlSchemaSequence)item).Items) || multiValue;
\r
1098 return multiValue;
\r
1101 void ImportSimpleContent (XmlQualifiedName typeQName, XmlTypeMapping map, XmlSchemaSimpleContent content, CodeIdentifiers classIds, bool isMixed)
\r
1103 XmlSchemaSimpleContentExtension ext = content.Content as XmlSchemaSimpleContentExtension;
\r
1104 ClassMap cmap = (ClassMap)map.ObjectMap;
\r
1105 XmlQualifiedName qname = GetContentBaseType (content.Content);
\r
1106 TypeData simpleType = null;
\r
1108 if (!IsPrimitiveTypeNamespace (qname.Namespace))
\r
1110 // Add base map members to this map
\r
1112 XmlTypeMapping baseMap = ImportType (qname, null, true);
\r
1113 BuildPendingMap (baseMap);
\r
1115 if (baseMap.IsSimpleType) {
\r
1116 simpleType = baseMap.TypeData;
\r
1118 ClassMap baseClassMap = (ClassMap)baseMap.ObjectMap;
\r
1120 foreach (XmlTypeMapMember member in baseClassMap.AllMembers)
\r
1121 cmap.AddMember (member);
\r
1123 map.BaseMap = baseMap;
\r
1124 baseMap.DerivedTypes.Add (map);
\r
1128 simpleType = FindBuiltInType (qname);
\r
1130 if (simpleType != null) {
\r
1131 XmlTypeMapMemberElement member = new XmlTypeMapMemberElement ();
\r
1132 member.Name = classIds.AddUnique("Value", member);
\r
1133 member.TypeData = simpleType;
\r
1134 member.ElementInfo.Add (CreateTextElementInfo (typeQName.Namespace, member, member.TypeData));
\r
1135 member.IsXmlTextCollector = true;
\r
1136 cmap.AddMember (member);
\r
1140 ImportAttributes (typeQName, cmap, ext.Attributes, ext.AnyAttribute, classIds);
\r
1143 TypeData FindBuiltInType (XmlQualifiedName qname)
\r
1145 XmlSchemaComplexType ct = (XmlSchemaComplexType) schemas.Find (qname, typeof(XmlSchemaComplexType));
\r
1148 XmlSchemaSimpleContent sc = ct.ContentModel as XmlSchemaSimpleContent;
\r
1149 if (sc == null) throw new InvalidOperationException ("Invalid schema");
\r
1150 return FindBuiltInType (GetContentBaseType (sc.Content));
\r
1153 XmlSchemaSimpleType st = (XmlSchemaSimpleType) schemas.Find (qname, typeof(XmlSchemaSimpleType));
\r
1155 return FindBuiltInType (qname, st);
\r
1157 if (IsPrimitiveTypeNamespace (qname.Namespace))
\r
1158 return TypeTranslator.GetPrimitiveTypeData (qname.Name);
\r
1160 throw new InvalidOperationException ("Definition of type '" + qname + "' not found");
\r
1163 TypeData FindBuiltInType (XmlQualifiedName qname, XmlSchemaSimpleType st)
\r
1165 if (CanBeEnum (st) && qname != null)
\r
1166 return ImportType (qname, null, true).TypeData;
\r
1168 if (st.Content is XmlSchemaSimpleTypeRestriction) {
\r
1169 XmlSchemaSimpleTypeRestriction rest = (XmlSchemaSimpleTypeRestriction) st.Content;
\r
1170 XmlQualifiedName bn = GetContentBaseType (rest);
\r
1171 if (bn == XmlQualifiedName.Empty && rest.BaseType != null)
\r
1172 return FindBuiltInType (qname, rest.BaseType);
\r
1174 return FindBuiltInType (bn);
\r
1176 else if (st.Content is XmlSchemaSimpleTypeList) {
\r
1177 return FindBuiltInType (GetContentBaseType (st.Content)).ListTypeData;
\r
1179 else if (st.Content is XmlSchemaSimpleTypeUnion) {
\r
1180 // MS.NET always import simple unions as string
\r
1181 return FindBuiltInType (new XmlQualifiedName ("string", XmlSchema.Namespace));
\r
1187 XmlQualifiedName GetContentBaseType (XmlSchemaObject ob)
\r
1189 if (ob is XmlSchemaSimpleContentExtension)
\r
1190 return ((XmlSchemaSimpleContentExtension)ob).BaseTypeName;
\r
1191 else if (ob is XmlSchemaSimpleContentRestriction)
\r
1192 return ((XmlSchemaSimpleContentRestriction)ob).BaseTypeName;
\r
1193 else if (ob is XmlSchemaSimpleTypeRestriction)
\r
1194 return ((XmlSchemaSimpleTypeRestriction)ob).BaseTypeName;
\r
1195 else if (ob is XmlSchemaSimpleTypeList)
\r
1196 return ((XmlSchemaSimpleTypeList)ob).ItemTypeName;
\r
1201 void ImportComplexContent (XmlQualifiedName typeQName, XmlTypeMapping map, XmlSchemaComplexContent content, CodeIdentifiers classIds, bool isMixed)
\r
1203 ClassMap cmap = (ClassMap)map.ObjectMap;
\r
1204 XmlQualifiedName qname;
\r
1206 XmlSchemaComplexContentExtension ext = content.Content as XmlSchemaComplexContentExtension;
\r
1207 if (ext != null) qname = ext.BaseTypeName;
\r
1208 else qname = ((XmlSchemaComplexContentRestriction)content.Content).BaseTypeName;
\r
1210 if (qname == typeQName)
\r
1211 throw new InvalidOperationException ("Cannot import schema for type '" + typeQName.Name + "' from namespace '" + typeQName.Namespace + "'. Redefine not supported");
\r
1213 // Add base map members to this map
\r
1215 XmlTypeMapping baseMap = ImportClass (qname);
\r
1216 BuildPendingMap (baseMap);
\r
1217 ClassMap baseClassMap = (ClassMap)baseMap.ObjectMap;
\r
1219 foreach (XmlTypeMapMember member in baseClassMap.AllMembers)
\r
1220 cmap.AddMember (member);
\r
1222 if (baseClassMap.XmlTextCollector != null) isMixed = false;
\r
1223 else if (content.IsMixed) isMixed = true;
\r
1225 map.BaseMap = baseMap;
\r
1226 baseMap.DerivedTypes.Add (map);
\r
1228 if (ext != null) {
\r
1229 // Add the members of this map
\r
1230 ImportParticleComplexContent (typeQName, cmap, ext.Particle, classIds, isMixed);
\r
1231 ImportAttributes (typeQName, cmap, ext.Attributes, ext.AnyAttribute, classIds);
\r
1234 if (isMixed) ImportParticleComplexContent (typeQName, cmap, null, classIds, true);
\r
1238 void ImportExtensionTypes (XmlQualifiedName qname)
\r
1240 foreach (XmlSchema schema in schemas) {
\r
1241 foreach (XmlSchemaObject sob in schema.Items)
\r
1243 XmlSchemaComplexType sct = sob as XmlSchemaComplexType;
\r
1244 if (sct != null && sct.ContentModel is XmlSchemaComplexContent) {
\r
1245 XmlQualifiedName exqname;
\r
1246 XmlSchemaComplexContentExtension ext = sct.ContentModel.Content as XmlSchemaComplexContentExtension;
\r
1247 if (ext != null) exqname = ext.BaseTypeName;
\r
1248 else exqname = ((XmlSchemaComplexContentRestriction)sct.ContentModel.Content).BaseTypeName;
\r
1249 if (exqname == qname)
\r
1250 ImportType (new XmlQualifiedName (sct.Name, schema.TargetNamespace), sct, null);
\r
1256 XmlTypeMapping ImportClassSimpleType (XmlQualifiedName typeQName, XmlSchemaSimpleType stype, XmlQualifiedName root)
\r
1258 if (CanBeEnum (stype))
\r
1260 // Create an enum map
\r
1262 CodeIdentifiers codeIdents = new CodeIdentifiers ();
\r
1263 XmlTypeMapping enumMap = CreateTypeMapping (typeQName, SchemaTypes.Enum, null);
\r
1264 enumMap.Documentation = GetDocumentation (stype);
\r
1266 bool isFlags = false;
\r
1267 if (stype.Content is XmlSchemaSimpleTypeList) {
\r
1268 stype = ((XmlSchemaSimpleTypeList)stype.Content).ItemType;
\r
1271 XmlSchemaSimpleTypeRestriction rest = (XmlSchemaSimpleTypeRestriction)stype.Content;
\r
1273 codeIdents.AddReserved (enumMap.TypeData.TypeName);
\r
1275 EnumMap.EnumMapMember[] members = new EnumMap.EnumMapMember [rest.Facets.Count];
\r
1276 for (int n=0; n<rest.Facets.Count; n++)
\r
1278 XmlSchemaEnumerationFacet enu = (XmlSchemaEnumerationFacet) rest.Facets[n];
\r
1279 string enumName = codeIdents.AddUnique(CodeIdentifier.MakeValid (enu.Value), enu);
\r
1280 members [n] = new EnumMap.EnumMapMember (enu.Value, enumName);
\r
1281 members [n].Documentation = GetDocumentation (enu);
\r
1283 enumMap.ObjectMap = new EnumMap (members, isFlags);
\r
1284 enumMap.IsSimpleType = true;
\r
1288 if (stype.Content is XmlSchemaSimpleTypeList)
\r
1290 XmlSchemaSimpleTypeList slist = (XmlSchemaSimpleTypeList)stype.Content;
\r
1291 TypeData arrayTypeData = FindBuiltInType (slist.ItemTypeName, stype);
\r
1293 ListMap listMap = new ListMap ();
\r
1295 listMap.ItemInfo = new XmlTypeMapElementInfoList ();
\r
1296 listMap.ItemInfo.Add (CreateElementInfo (typeQName.Namespace, null, "Item", arrayTypeData.ListItemTypeData, false, XmlSchemaForm.None));
\r
1298 XmlTypeMapping map = CreateArrayTypeMapping (typeQName, arrayTypeData);
\r
1299 map.ObjectMap = listMap;
\r
1300 map.IsSimpleType = true;
\r
1304 // It is an extension of a primitive or known type
\r
1306 TypeData typeData = FindBuiltInType (typeQName, stype);
\r
1307 XmlTypeMapping rmap = GetTypeMapping (typeData);
\r
1309 // The resulting map must be a simple type. It needs to be explicitely set for arrays
\r
1310 rmap.IsSimpleType = true;
\r
1314 bool CanBeEnum (XmlSchemaSimpleType stype)
\r
1316 if (stype.Content is XmlSchemaSimpleTypeRestriction)
\r
1318 XmlSchemaSimpleTypeRestriction rest = (XmlSchemaSimpleTypeRestriction)stype.Content;
\r
1319 if (rest.Facets.Count == 0) return false;
\r
1320 foreach (object ob in rest.Facets)
\r
1321 if (!(ob is XmlSchemaEnumerationFacet)) return false;
\r
1324 else if (stype.Content is XmlSchemaSimpleTypeList)
\r
1326 XmlSchemaSimpleTypeList list = (XmlSchemaSimpleTypeList) stype.Content;
\r
1327 return (list.ItemType != null && CanBeEnum (list.ItemType));
\r
1332 bool CanBeArray (XmlQualifiedName typeQName, XmlSchemaComplexType stype)
\r
1334 if (encodedFormat)
\r
1336 XmlSchemaComplexContent content = stype.ContentModel as XmlSchemaComplexContent;
\r
1337 if (content == null) return false;
\r
1338 XmlSchemaComplexContentRestriction rest = content.Content as XmlSchemaComplexContentRestriction;
\r
1339 if (rest == null) return false;
\r
1340 return rest.BaseTypeName == arrayType;
\r
1344 if (stype.Attributes.Count > 0 || stype.AnyAttribute != null) return false;
\r
1345 else return !stype.IsMixed && CanBeArray (typeQName, stype.Particle, false);
\r
1349 bool CanBeArray (XmlQualifiedName typeQName, XmlSchemaParticle particle, bool multiValue)
\r
1351 // To be an array, there can't be a direct child of type typeQName
\r
1353 if (particle == null) return false;
\r
1355 multiValue = multiValue || particle.MaxOccurs > 1;
\r
1357 if (particle is XmlSchemaGroupRef)
\r
1358 return CanBeArray (typeQName, GetRefGroupParticle ((XmlSchemaGroupRef)particle), multiValue);
\r
1360 if (particle is XmlSchemaElement)
\r
1362 XmlSchemaElement elem = (XmlSchemaElement)particle;
\r
1363 if (!elem.RefName.IsEmpty)
\r
1364 return CanBeArray (typeQName, FindRefElement (elem), multiValue);
\r
1366 return multiValue && !typeQName.Equals (((XmlSchemaElement)particle).SchemaTypeName);
\r
1369 if (particle is XmlSchemaAny)
\r
1370 return multiValue;
\r
1372 if (particle is XmlSchemaSequence)
\r
1374 XmlSchemaSequence seq = particle as XmlSchemaSequence;
\r
1375 if (seq.Items.Count != 1) return false;
\r
1376 return CanBeArray (typeQName, (XmlSchemaParticle)seq.Items[0], multiValue);
\r
1379 if (particle is XmlSchemaChoice)
\r
1381 // Can be array if all choices have different types
\r
1382 ArrayList types = new ArrayList ();
\r
1383 if(!CheckChoiceType (typeQName, particle, types, ref multiValue)) return false;
\r
1384 return multiValue;
\r
1390 bool CheckChoiceType (XmlQualifiedName typeQName, XmlSchemaParticle particle, ArrayList types, ref bool multiValue)
\r
1392 XmlQualifiedName type = null;
\r
1394 multiValue = multiValue || particle.MaxOccurs > 1;
\r
1396 if (particle is XmlSchemaGroupRef)
\r
1397 return CheckChoiceType (typeQName, GetRefGroupParticle ((XmlSchemaGroupRef)particle), types, ref multiValue);
\r
1399 if (particle is XmlSchemaElement) {
\r
1401 XmlSchemaElement elem = (XmlSchemaElement)particle;
\r
1402 XmlSchemaElement refElem = GetRefElement (typeQName, elem, out ns);
\r
1403 if (refElem.SchemaType != null) return true;
\r
1404 type = refElem.SchemaTypeName;
\r
1406 else if (particle is XmlSchemaAny) {
\r
1409 else if (particle is XmlSchemaSequence)
\r
1411 XmlSchemaSequence seq = particle as XmlSchemaSequence;
\r
1412 foreach (XmlSchemaParticle par in seq.Items)
\r
1413 if (!CheckChoiceType (typeQName, par, types, ref multiValue)) return false;
\r
1416 else if (particle is XmlSchemaChoice)
\r
1418 foreach (XmlSchemaParticle choice in ((XmlSchemaChoice)particle).Items)
\r
1419 if (!CheckChoiceType (typeQName, choice, types, ref multiValue)) return false;
\r
1423 if (typeQName.Equals (type)) return false;
\r
1425 // For primitive types, compare using CLR types, since several
\r
1426 // xml types can be mapped to a single CLR type
\r
1429 if (IsPrimitiveTypeNamespace (type.Namespace))
\r
1430 t = TypeTranslator.GetPrimitiveTypeData (type.Name).FullTypeName + ":" + type.Namespace;
\r
1433 t = type.Name + ":" + type.Namespace;
\r
1435 if (types.Contains (t)) return false;
\r
1440 bool CanBeAnyElement (XmlSchemaComplexType stype)
\r
1442 XmlSchemaSequence seq = stype.Particle as XmlSchemaSequence;
\r
1443 return (seq != null) && (seq.Items.Count == 1) && (seq.Items[0] is XmlSchemaAny);
\r
1446 Type GetAnyElementType (XmlSchemaComplexType stype)
\r
1448 XmlSchemaSequence seq = stype.Particle as XmlSchemaSequence;
\r
1450 if ((seq == null) || (seq.Items.Count != 1) || !(seq.Items[0] is XmlSchemaAny))
\r
1453 if (encodedFormat)
\r
1454 return typeof(object);
\r
1456 XmlSchemaAny any = seq.Items[0] as XmlSchemaAny;
\r
1457 if (any.MaxOccurs == 1)
\r
1459 if (stype.IsMixed)
\r
1460 return typeof(XmlNode);
\r
1462 return typeof(XmlElement);
\r
1466 if (stype.IsMixed)
\r
1467 return typeof(XmlNode[]);
\r
1469 return typeof(XmlElement[]);
\r
1473 bool CanBeIXmlSerializable (XmlSchemaComplexType stype)
\r
1475 XmlSchemaSequence seq = stype.Particle as XmlSchemaSequence;
\r
1476 if (seq == null) return false;
\r
1477 if (seq.Items.Count != 2) return false;
\r
1478 XmlSchemaElement elem = seq.Items[0] as XmlSchemaElement;
\r
1479 if (elem == null) return false;
\r
1480 if (elem.RefName != new XmlQualifiedName ("schema",XmlSchema.Namespace)) return false;
\r
1481 return (seq.Items[1] is XmlSchemaAny);
\r
1484 XmlTypeMapping ImportXmlSerializableMapping (string ns)
\r
1486 XmlQualifiedName qname = new XmlQualifiedName ("System.Data.DataSet",ns);
\r
1487 XmlTypeMapping map = mappedTypes [qname] as XmlTypeMapping;
\r
1488 if (map != null) return map;
\r
1490 TypeData typeData = new TypeData ("System.Data.DataSet", "System.Data.DataSet", "System.Data.DataSet", SchemaTypes.XmlSerializable, null);
\r
1491 map = new XmlTypeMapping ("System.Data.DataSet", "", typeData, "System.Data.DataSet", ns);
\r
1492 map.IncludeInSchema = true;
\r
1493 mappedTypes [qname] = map;
\r
1494 dataMappedTypes [typeData] = map;
\r
1498 XmlTypeMapElementInfo CreateElementInfo (string ns, XmlTypeMapMember member, string name, TypeData typeData, bool isNillable, XmlSchemaForm form)
\r
1500 if (typeData.IsComplexType)
\r
1501 return CreateElementInfo (ns, member, name, typeData, isNillable, form, GetTypeMapping (typeData));
\r
1503 return CreateElementInfo (ns, member, name, typeData, isNillable, form, null);
\r
1506 XmlTypeMapElementInfo CreateElementInfo (string ns, XmlTypeMapMember member, string name, TypeData typeData, bool isNillable, XmlSchemaForm form, XmlTypeMapping emap)
\r
1508 XmlTypeMapElementInfo einfo = new XmlTypeMapElementInfo (member, typeData);
\r
1509 einfo.ElementName = name;
\r
1510 einfo.Namespace = ns;
\r
1511 einfo.IsNullable = isNillable;
\r
1512 einfo.Form = form;
\r
1513 if (typeData.IsComplexType)
\r
1514 einfo.MappedType = emap;
\r
1518 XmlTypeMapElementInfo CreateTextElementInfo (string ns, XmlTypeMapMember member, TypeData typeData)
\r
1520 XmlTypeMapElementInfo einfo = new XmlTypeMapElementInfo (member, typeData);
\r
1521 einfo.IsTextElement = true;
\r
1522 einfo.WrappedElement = false;
\r
1523 if (typeData.IsComplexType)
\r
1524 einfo.MappedType = GetTypeMapping (typeData);
\r
1528 XmlTypeMapping CreateTypeMapping (XmlQualifiedName typeQName, SchemaTypes schemaType, XmlQualifiedName root)
\r
1530 string typeName = CodeIdentifier.MakeValid (typeQName.Name);
\r
1531 typeName = typeIdentifiers.AddUnique (typeName, null);
\r
1533 TypeData typeData = new TypeData (typeName, typeName, typeName, schemaType, null);
\r
1537 if (root != null) {
\r
1538 rootElem = root.Name;
\r
1539 rootNs = root.Namespace;
\r
1542 rootElem = typeQName.Name;
\r
1546 XmlTypeMapping map = new XmlTypeMapping (rootElem, rootNs, typeData, typeQName.Name, typeQName.Namespace);
\r
1547 map.IncludeInSchema = true;
\r
1548 mappedTypes [typeQName] = map;
\r
1549 dataMappedTypes [typeData] = map;
\r
1554 XmlTypeMapping CreateArrayTypeMapping (XmlQualifiedName typeQName, TypeData arrayTypeData)
\r
1556 XmlTypeMapping map;
\r
1557 if (encodedFormat) map = new XmlTypeMapping ("Array", XmlSerializer.EncodingNamespace, arrayTypeData, "Array", XmlSerializer.EncodingNamespace);
\r
1558 else map = new XmlTypeMapping (arrayTypeData.XmlType, typeQName.Namespace, arrayTypeData, arrayTypeData.XmlType, typeQName.Namespace);
\r
1560 map.IncludeInSchema = true;
\r
1561 mappedTypes [typeQName] = map;
\r
1562 dataMappedTypes [arrayTypeData] = map;
\r
1567 XmlSchemaElement GetRefElement (XmlQualifiedName typeQName, XmlSchemaElement elem, out string ns)
\r
1570 if (!elem.RefName.IsEmpty)
\r
1572 ns = elem.RefName.Namespace;
\r
1573 return FindRefElement (elem);
\r
1577 ns = typeQName.Namespace;
\r
1582 XmlSchemaAttribute GetRefAttribute (XmlQualifiedName typeQName, XmlSchemaAttribute attr, out string ns)
\r
1584 if (!attr.RefName.IsEmpty)
\r
1586 ns = attr.RefName.Namespace;
\r
1587 XmlSchemaAttribute at = FindRefAttribute (attr.RefName);
\r
1588 if (at == null) throw new InvalidOperationException ("The attribute " + attr.RefName + " is missing");
\r
1593 ns = typeQName.Namespace;
\r
1598 TypeData GetElementTypeData (XmlQualifiedName typeQName, XmlSchemaElement elem, XmlQualifiedName root, out XmlTypeMapping map)
\r
1600 bool sharedAnnType = false;
\r
1603 if (!elem.RefName.IsEmpty) {
\r
1604 XmlSchemaElement refElem = FindRefElement (elem);
\r
1605 if (refElem == null) throw new InvalidOperationException ("Global element not found: " + elem.RefName);
\r
1606 root = elem.RefName;
\r
1608 sharedAnnType = true;
\r
1612 if (!elem.SchemaTypeName.IsEmpty) {
\r
1613 td = GetTypeData (elem.SchemaTypeName, root);
\r
1614 map = GetRegisteredTypeMapping (elem.SchemaTypeName);
\r
1616 else if (elem.SchemaType == null)
\r
1617 td = TypeTranslator.GetTypeData (typeof(object));
\r
1619 td = GetTypeData (elem.SchemaType, typeQName, elem.Name, sharedAnnType, root);
\r
1621 if (map == null && td.IsComplexType)
\r
1622 map = GetTypeMapping (td);
\r
1627 TypeData GetAttributeTypeData (XmlQualifiedName typeQName, XmlSchemaAttribute attr)
\r
1629 bool sharedAnnType = false;
\r
1631 if (!attr.RefName.IsEmpty) {
\r
1632 XmlSchemaAttribute refAtt = FindRefAttribute (attr.RefName);
\r
1633 if (refAtt == null) throw new InvalidOperationException ("Global attribute not found: " + attr.RefName);
\r
1635 sharedAnnType = true;
\r
1638 if (!attr.SchemaTypeName.IsEmpty) return GetTypeData (attr.SchemaTypeName, null);
\r
1639 if (attr.SchemaType == null) return TypeTranslator.GetTypeData (typeof(string));
\r
1640 else return GetTypeData (attr.SchemaType, typeQName, attr.Name, sharedAnnType, null);
\r
1643 TypeData GetTypeData (XmlQualifiedName typeQName, XmlQualifiedName root)
\r
1645 if (IsPrimitiveTypeNamespace (typeQName.Namespace)) {
\r
1646 XmlTypeMapping map = ImportType (typeQName, root, false);
\r
1647 if (map != null) return map.TypeData;
\r
1648 else return TypeTranslator.GetPrimitiveTypeData (typeQName.Name);
\r
1651 if (encodedFormat && typeQName.Namespace == "")
\r
1652 return TypeTranslator.GetPrimitiveTypeData (typeQName.Name);
\r
1654 return ImportType (typeQName, root, true).TypeData;
\r
1657 TypeData GetTypeData (XmlSchemaType stype, XmlQualifiedName typeQNname, string propertyName, bool sharedAnnType, XmlQualifiedName root)
\r
1661 if (sharedAnnType)
\r
1663 // Anonymous types defined in root elements or attributes can be shared among all elements that
\r
1664 // reference this root element or attribute
\r
1665 TypeData std = sharedAnonymousTypes [stype] as TypeData;
\r
1666 if (std != null) return std;
\r
1667 baseName = propertyName;
\r
1670 baseName = typeQNname.Name + typeIdentifiers.MakeRightCase (propertyName);
\r
1672 baseName = elemIdentifiers.AddUnique (baseName, stype);
\r
1674 XmlQualifiedName newName;
\r
1675 newName = new XmlQualifiedName (baseName, typeQNname.Namespace);
\r
1677 XmlTypeMapping map = ImportType (newName, stype, root);
\r
1678 if (sharedAnnType) sharedAnonymousTypes [stype] = map.TypeData;
\r
1680 return map.TypeData;
\r
1683 XmlTypeMapping GetTypeMapping (TypeData typeData)
\r
1685 if (typeData.Type == typeof(object) && !anyTypeImported)
\r
1686 ImportAllObjectTypes ();
\r
1688 XmlTypeMapping map = (XmlTypeMapping) dataMappedTypes [typeData];
\r
1689 if (map != null) return map;
\r
1691 if (typeData.IsListType)
\r
1693 // Create an array map for the type
\r
1695 XmlTypeMapping itemMap = GetTypeMapping (typeData.ListItemTypeData);
\r
1697 map = new XmlTypeMapping (typeData.XmlType, itemMap.Namespace, typeData, typeData.XmlType, itemMap.Namespace);
\r
1698 map.IncludeInSchema = true;
\r
1700 ListMap listMap = new ListMap ();
\r
1701 listMap.ItemInfo = new XmlTypeMapElementInfoList();
\r
1702 listMap.ItemInfo.Add (CreateElementInfo (itemMap.Namespace, null, typeData.ListItemTypeData.XmlType, typeData.ListItemTypeData, false, XmlSchemaForm.None));
\r
1703 map.ObjectMap = listMap;
\r
1705 mappedTypes [new XmlQualifiedName(map.ElementName, map.Namespace)] = map;
\r
1706 dataMappedTypes [typeData] = map;
\r
1709 else if (typeData.SchemaType == SchemaTypes.Primitive || typeData.Type == typeof(object) || typeof(XmlNode).IsAssignableFrom(typeData.Type))
\r
1711 return CreateSystemMap (typeData);
\r
1714 throw new InvalidOperationException ("Map for type " + typeData.TypeName + " not found");
\r
1717 void AddObjectDerivedMap (XmlTypeMapping map)
\r
1719 TypeData typeData = TypeTranslator.GetTypeData (typeof(object));
\r
1720 XmlTypeMapping omap = (XmlTypeMapping) dataMappedTypes [typeData];
\r
1722 omap = CreateSystemMap (typeData);
\r
1723 omap.DerivedTypes.Add (map);
\r
1726 XmlTypeMapping CreateSystemMap (TypeData typeData)
\r
1728 XmlTypeMapping map = new XmlTypeMapping (typeData.XmlType, XmlSchema.Namespace, typeData, typeData.XmlType, XmlSchema.Namespace);
\r
1729 map.IncludeInSchema = false;
\r
1730 map.ObjectMap = new ClassMap ();
\r
1731 dataMappedTypes [typeData] = map;
\r
1735 void ImportAllObjectTypes ()
\r
1737 // All complex types are subtypes of anyType, so all of them
\r
1738 // must also be imported
\r
1740 anyTypeImported = true;
\r
1741 foreach (XmlSchema schema in schemas) {
\r
1742 foreach (XmlSchemaObject sob in schema.Items)
\r
1744 XmlSchemaComplexType sct = sob as XmlSchemaComplexType;
\r
1746 ImportType (new XmlQualifiedName (sct.Name, schema.TargetNamespace), sct, null);
\r
1752 XmlTypeMapping GetRegisteredTypeMapping (XmlQualifiedName typeQName)
\r
1754 return (XmlTypeMapping) mappedTypes [typeQName];
\r
1757 XmlSchemaParticle GetRefGroupParticle (XmlSchemaGroupRef refGroup)
\r
1759 XmlSchemaGroup grp = (XmlSchemaGroup) schemas.Find (refGroup.RefName, typeof (XmlSchemaGroup));
\r
1760 return grp.Particle;
\r
1763 XmlSchemaElement FindRefElement (XmlSchemaElement elem)
\r
1765 XmlSchemaElement refelem = (XmlSchemaElement) schemas.Find (elem.RefName, typeof(XmlSchemaElement));
\r
1766 if (refelem != null) return refelem;
\r
1768 if (IsPrimitiveTypeNamespace (elem.RefName.Namespace))
\r
1770 if (anyElement != null) return anyElement;
\r
1771 anyElement = new XmlSchemaElement ();
\r
1772 anyElement.Name = "any";
\r
1773 anyElement.SchemaTypeName = anyType;
\r
1774 return anyElement;
\r
1779 XmlSchemaAttribute FindRefAttribute (XmlQualifiedName refName)
\r
1781 if (refName.Namespace == XmlNamespace)
\r
1783 XmlSchemaAttribute at = new XmlSchemaAttribute ();
\r
1784 at.Name = refName.Name;
\r
1785 at.SchemaTypeName = new XmlQualifiedName ("string",XmlSchema.Namespace);
\r
1788 return (XmlSchemaAttribute) schemas.Find (refName, typeof(XmlSchemaAttribute));
\r
1791 XmlSchemaAttributeGroup FindRefAttributeGroup (XmlQualifiedName refName)
\r
1793 XmlSchemaAttributeGroup grp = (XmlSchemaAttributeGroup) schemas.Find (refName, typeof(XmlSchemaAttributeGroup));
\r
1794 foreach (XmlSchemaObject at in grp.Attributes)
\r
1796 if (at is XmlSchemaAttributeGroupRef && ((XmlSchemaAttributeGroupRef)at).RefName == refName)
\r
1797 throw new InvalidOperationException ("Cannot import attribute group '" + refName.Name + "' from namespace '" + refName.Namespace + "'. Redefine not supported");
\r
1803 XmlTypeMapping ReflectType (Type type)
\r
1805 TypeData typeData = TypeTranslator.GetTypeData (type);
\r
1806 return ReflectType (typeData, (string) null);
\r
1809 XmlTypeMapping ReflectType (TypeData typeData, string ns)
\r
1811 if (!encodedFormat)
\r
1813 if (auxXmlRefImporter == null) auxXmlRefImporter = new XmlReflectionImporter ();
\r
1814 return auxXmlRefImporter.ImportTypeMapping (typeData, ns);
\r
1818 if (auxSoapRefImporter == null) auxSoapRefImporter = new SoapReflectionImporter ();
\r
1819 return auxSoapRefImporter.ImportTypeMapping (typeData, ns);
\r
1824 string GetDocumentation (XmlSchemaAnnotated elem)
\r
1827 XmlSchemaAnnotation anot = elem.Annotation;
\r
1828 if (anot == null || anot.Items == null) return null;
\r
1830 foreach (object ob in anot.Items)
\r
1832 XmlSchemaDocumentation doc = ob as XmlSchemaDocumentation;
\r
1833 if (doc != null && doc.Markup != null && doc.Markup.Length > 0) {
\r
1834 if (res != string.Empty) res += "\n";
\r
1835 foreach (XmlNode node in doc.Markup)
\r
1836 res += node.Value;
\r
1842 bool IsPrimitiveTypeNamespace (string ns)
\r
1844 return (ns == XmlSchema.Namespace) || (encodedFormat && ns == XmlSerializer.EncodingNamespace);
\r
1847 #endregion // Methods
\r