?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
**** Merged from MCS ****
[mono-project.git] / mcs / class / System.XML / System.Xml.Serialization / XmlTypeMapping.cs
blob0b64944f21dde7dc432566de173a202670cdf977
1 //
2 // XmlTypeMapping.cs:
3 //
4 // Author:
5 // John Donagher (john@webmeta.com)
6 // Lluis Sanchez Gual (lluis@ximian.com)
7 //
8 // (C) 2002 John Donagher
9 //
10
11 //
12 // Permission is hereby granted, free of charge, to any person obtaining
13 // a copy of this software and associated documentation files (the
14 // "Software"), to deal in the Software without restriction, including
15 // without limitation the rights to use, copy, modify, merge, publish,
16 // distribute, sublicense, and/or sell copies of the Software, and to
17 // permit persons to whom the Software is furnished to do so, subject to
18 // the following conditions:
19 //
20 // The above copyright notice and this permission notice shall be
21 // included in all copies or substantial portions of the Software.
22 //
23 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
24 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
25 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
26 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
27 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
28 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
29 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
30 //
31
32 using System.Xml;
33 using System;
34 using System.Collections;
35 using System.Globalization;
36
37 namespace System.Xml.Serialization
38 {
39 public class XmlTypeMapping : XmlMapping
40 {
41 private string xmlType;
42 private string xmlTypeNamespace;
43 TypeData type;
44 XmlTypeMapping baseMap;
45 bool multiReferenceType = false;
46 bool isSimpleType;
47 string documentation;
48 bool includeInSchema;
49 bool isNullable = true;
50
51 ArrayList _derivedTypes = new ArrayList();
52
53 internal XmlTypeMapping(string elementName, string ns, TypeData typeData, string xmlType, string xmlTypeNamespace)
54 : base (elementName, ns)
55 {
56 this.type = typeData;
57 this.xmlType = xmlType;
58 this.xmlTypeNamespace = xmlTypeNamespace;
59 }
60
61 #if !NET_2_0
62 public string ElementName
63 {
64 get { return _elementName; }
65 }
66
67 public string Namespace
68 {
69 get { return _namespace; }
70 }
71 #endif
72
73 public string TypeFullName
74 {
75 get { return type.FullTypeName; }
76 }
77
78 public string TypeName
79 {
80 get { return type.TypeName; }
81 }
82
83 internal TypeData TypeData
84 {
85 get { return type; }
86 }
87
88 internal string XmlType
89 {
90 get { return xmlType; }
91 }
92
93 internal string XmlTypeNamespace
94 {
95 get { return xmlTypeNamespace; }
96 }
97
98 internal ArrayList DerivedTypes
99 {
100 get { return _derivedTypes; }
101 set { _derivedTypes = value; }
102 }
103
104 internal bool MultiReferenceType
105 {
106 get { return multiReferenceType; }
107 set { multiReferenceType = value; }
108 }
109
110 internal XmlTypeMapping BaseMap
111 {
112 get { return baseMap; }
113 set { baseMap = value; }
114 }
115
116 internal bool IsSimpleType
117 {
118 get { return isSimpleType; }
119 set { isSimpleType = value; }
120 }
121
122 internal string Documentation
123 {
124 set { documentation = value; }
125 get { return documentation; }
126 }
127
128 internal bool IncludeInSchema
129 {
130 get { return includeInSchema; }
131 set { includeInSchema = value; }
132 }
133
134 internal bool IsNullable
135 {
136 get { return isNullable; }
137 set { isNullable = value; }
138 }
139
140 internal XmlTypeMapping GetRealTypeMap (string objectFullTypeName)
141 {
142 // Returns the map for a subtype of this map's type
143
144 objectFullTypeName = objectFullTypeName.Replace ('+','.');
145 if (TypeFullName == objectFullTypeName) return this;
146 for (int n=0; n<_derivedTypes.Count; n++) {
147 XmlTypeMapping map = (XmlTypeMapping) _derivedTypes[n];
148 if (map.TypeFullName == objectFullTypeName) return map;
149 }
150
151 return null;
152 }
153
154 internal XmlTypeMapping GetRealElementMap (string name, string ens)
155 {
156 if (xmlType == name && xmlTypeNamespace == ens) return this;
157 foreach (XmlTypeMapping map in _derivedTypes)
158 if (map.xmlType == name && map.xmlTypeNamespace == ens) return map;
159
160 return null;
161 }
162
163 internal void UpdateRoot (XmlQualifiedName qname)
164 {
165 if (qname != null) {
166 this._elementName = qname.Name;
167 this._namespace = qname.Namespace;
168 }
169 }
170 }
171
172 // Mapping info for classes and structs
173
174 internal class ClassMap: ObjectMap
175 {
176 Hashtable _elements = new Hashtable ();
177 ArrayList _elementMembers;
178 Hashtable _attributeMembers;
179 XmlTypeMapMemberAttribute[] _attributeMembersArray;
180 XmlTypeMapElementInfo[] _elementsByIndex;
181 ArrayList _flatLists;
182 ArrayList _allMembers = new ArrayList ();
183 ArrayList _membersWithDefault;
184 XmlTypeMapMemberAnyElement _defaultAnyElement;
185 XmlTypeMapMemberAnyAttribute _defaultAnyAttribute;
186 XmlTypeMapMemberNamespaces _namespaceDeclarations;
187 XmlTypeMapMember _xmlTextCollector;
188 XmlTypeMapMember _returnMember;
189 bool _ignoreMemberNamespace;
190 bool _canBeSimpleType = true;
191
192 public void AddMember (XmlTypeMapMember member)
193 {
194 _allMembers.Add (member);
195
196 if (!(member.DefaultValue is System.DBNull)) {
197 if (_membersWithDefault == null) _membersWithDefault = new ArrayList ();
198 _membersWithDefault.Add (member);
199 }
200
201 if (member.IsReturnValue)
202 _returnMember = member;
203
204 if (member is XmlTypeMapMemberAttribute)
205 {
206 XmlTypeMapMemberAttribute atm = (XmlTypeMapMemberAttribute)member;
207 if (_attributeMembers == null) _attributeMembers = new Hashtable();
208 string key = BuildKey (atm.AttributeName, atm.Namespace);
209 if (_attributeMembers.ContainsKey (key))
210 throw new InvalidOperationException ("The XML attribute named '" + atm.AttributeName + "' from namespace '" + atm.Namespace + "' already present in the current scope. Use XML attributes to specify another XML name or namespace for the attribute.");
211 member.Index = _attributeMembers.Count;
212 _attributeMembers.Add (key, member);
213 return;
214 }
215 else if (member is XmlTypeMapMemberFlatList)
216 {
217 RegisterFlatList ((XmlTypeMapMemberFlatList)member);
218 }
219 else if (member is XmlTypeMapMemberAnyElement)
220 {
221 XmlTypeMapMemberAnyElement mem = (XmlTypeMapMemberAnyElement) member;
222 if (mem.IsDefaultAny) _defaultAnyElement = mem;
223 if (mem.TypeData.IsListType) RegisterFlatList (mem);
224 }
225 else if (member is XmlTypeMapMemberAnyAttribute)
226 {
227 _defaultAnyAttribute = (XmlTypeMapMemberAnyAttribute) member;
228 return;
229 }
230 else if (member is XmlTypeMapMemberNamespaces)
231 {
232 _namespaceDeclarations = (XmlTypeMapMemberNamespaces) member;
233 return;
234 }
235
236 if (member is XmlTypeMapMemberElement && ((XmlTypeMapMemberElement)member).IsXmlTextCollector)
237 {
238 if (_xmlTextCollector != null) throw new InvalidOperationException ("XmlTextAttribute can only be applied once in a class");
239 _xmlTextCollector = member;
240 }
241
242 if (_elementMembers == null) {
243 _elementMembers = new ArrayList();
244 _elements = new Hashtable();
245 }
246
247 member.Index = _elementMembers.Count;
248 _elementMembers.Add (member);
249
250 ICollection elemsInfo = ((XmlTypeMapMemberElement)member).ElementInfo;
251 foreach (XmlTypeMapElementInfo elem in elemsInfo)
252 {
253 string key = BuildKey (elem.ElementName, elem.Namespace);
254 if (_elements.ContainsKey (key))
255 throw new InvalidOperationException ("The XML element named '" + elem.ElementName + "' from namespace '" + elem.Namespace + "' already present in the current scope. Use XML attributes to specify another XML name or namespace for the element.");
256 _elements.Add (key, elem);
257 }
258 }
259
260 void RegisterFlatList (XmlTypeMapMemberExpandable member)
261 {
262 if (_flatLists == null) _flatLists = new ArrayList ();
263 member.FlatArrayIndex = _flatLists.Count;
264 _flatLists.Add (member);
265 }
266
267 public XmlTypeMapMemberAttribute GetAttribute (string name, string ns)
268 {
269 if (_attributeMembers == null) return null;
270 return (XmlTypeMapMemberAttribute)_attributeMembers [BuildKey(name,ns)];
271 }
272
273 public XmlTypeMapElementInfo GetElement (string name, string ns)
274 {
275 if (_elements == null) return null;
276 return (XmlTypeMapElementInfo)_elements [BuildKey(name,ns)];
277 }
278
279 public XmlTypeMapElementInfo GetElement (int index)
280 {
281 if (_elements == null) return null;
282
283 if (_elementsByIndex == null)
284 {
285 _elementsByIndex = new XmlTypeMapElementInfo [_elementMembers.Count];
286 foreach (XmlTypeMapMemberElement mem in _elementMembers)
287 {
288 if (mem.ElementInfo.Count != 1)
289 throw new InvalidOperationException ("Read by order only possible for encoded/bare format");
290
291 _elementsByIndex [mem.Index] = (XmlTypeMapElementInfo) mem.ElementInfo [0];
292 }
293 }
294
295 return _elementsByIndex [index];
296 }
297
298 private string BuildKey (string name, string ns)
299 {
300 if (_ignoreMemberNamespace) return name;
301 else return name + " / " + ns;
302 }
303
304 public ICollection AllElementInfos
305 {
306 get { return _elements.Values; }
307 }
308
309
310 public bool IgnoreMemberNamespace
311 {
312 get { return _ignoreMemberNamespace; }
313 set { _ignoreMemberNamespace = value; }
314 }
315
316 public XmlTypeMapMember FindMember (string name)
317 {
318 for (int n=0; n<_allMembers.Count; n++)
319 if (((XmlTypeMapMember)_allMembers[n]).Name == name) return (XmlTypeMapMember)_allMembers[n];
320 return null;
321 }
322
323 public XmlTypeMapMemberAnyElement DefaultAnyElementMember
324 {
325 get { return _defaultAnyElement; }
326 }
327
328 public XmlTypeMapMemberAnyAttribute DefaultAnyAttributeMember
329 {
330 get { return _defaultAnyAttribute; }
331 }
332
333 public XmlTypeMapMemberNamespaces NamespaceDeclarations
334 {
335 get { return _namespaceDeclarations; }
336 }
337
338 public ICollection AttributeMembers
339 {
340 get
341 {
342 if (_attributeMembers == null) return null;
343 if (_attributeMembersArray != null) return _attributeMembersArray;
344
345 _attributeMembersArray = new XmlTypeMapMemberAttribute[_attributeMembers.Count];
346 foreach (XmlTypeMapMemberAttribute mem in _attributeMembers.Values)
347 _attributeMembersArray [mem.Index] = mem;
348 return _attributeMembersArray;
349 }
350 }
351
352 public ICollection ElementMembers
353 {
354 get { return _elementMembers; }
355 }
356
357 public ArrayList AllMembers
358 {
359 get { return _allMembers; }
360 }
361
362 public ArrayList FlatLists
363 {
364 get { return _flatLists; }
365 }
366
367 public ArrayList MembersWithDefault
368 {
369 get { return _membersWithDefault; }
370 }
371
372 public XmlTypeMapMember XmlTextCollector
373 {
374 get { return _xmlTextCollector; }
375 }
376
377 public XmlTypeMapMember ReturnMember
378 {
379 get { return _returnMember; }
380 }
381
382 public XmlQualifiedName SimpleContentBaseType
383 {
384 get
385 {
386 if (!_canBeSimpleType || _elementMembers == null || _elementMembers.Count != 1) return null;
387 XmlTypeMapMemberElement member = (XmlTypeMapMemberElement) _elementMembers[0];
388 if (member.ElementInfo.Count != 1) return null;
389 XmlTypeMapElementInfo einfo = (XmlTypeMapElementInfo) member.ElementInfo[0];
390 if (!einfo.IsTextElement) return null;
391 if (member.TypeData.SchemaType == SchemaTypes.Primitive || member.TypeData.SchemaType == SchemaTypes.Enum)
392 return new XmlQualifiedName (einfo.TypeData.XmlType, einfo.DataTypeNamespace);
393 return null;
394 }
395 }
396
397 public void SetCanBeSimpleType (bool can)
398 {
399 _canBeSimpleType = can;
400 }
401
402 public bool HasSimpleContent
403 {
404 get
405 {
406 return SimpleContentBaseType != null;
407 }
408 }
409
410 }
411
412 // Mapping info for arrays and lists
413
414 internal class ListMap: ObjectMap
415 {
416 XmlTypeMapElementInfoList _itemInfo;
417 bool _gotNestedMapping;
418 XmlTypeMapping _nestedArrayMapping;
419
420 public bool IsMultiArray
421 {
422 get
423 {
424 return (NestedArrayMapping != null);
425 }
426 }
427
428 public XmlTypeMapping NestedArrayMapping
429 {
430 get
431 {
432 if (_gotNestedMapping) return _nestedArrayMapping;
433 _gotNestedMapping = true;
434
435 _nestedArrayMapping = ((XmlTypeMapElementInfo)_itemInfo[0]).MappedType;
436
437 if (_nestedArrayMapping == null) return null;
438
439 if (_nestedArrayMapping.TypeData.SchemaType != SchemaTypes.Array) {
440 _nestedArrayMapping = null; return null;
441 }
442
443 foreach (XmlTypeMapElementInfo elem in _itemInfo)
444 if (elem.MappedType != _nestedArrayMapping) {
445 _nestedArrayMapping = null;
446 return null;
447 }
448
449 return _nestedArrayMapping;
450 }
451 }
452
453 public XmlTypeMapElementInfoList ItemInfo
454 {
455
456 get { return _itemInfo; }
457 set { _itemInfo = value; }
458 }
459
460 public XmlTypeMapElementInfo FindElement (object memberValue)
461 {
462 if (_itemInfo.Count == 1)
463 return (XmlTypeMapElementInfo) _itemInfo[0];
464 else
465 {
466 if (memberValue == null) return null;
467 Type type = memberValue.GetType();
468 foreach (XmlTypeMapElementInfo elem in _itemInfo)
469 if (elem.TypeData.Type == type) return elem;
470 }
471 return null;
472 }
473
474 public XmlTypeMapElementInfo FindElement (string elementName, string ns)
475 {
476 foreach (XmlTypeMapElementInfo elem in _itemInfo)
477 if (elem.ElementName == elementName && elem.Namespace == ns) return elem;
478 return null;
479 }
480
481 public XmlTypeMapElementInfo FindTextElement ()
482 {
483 foreach (XmlTypeMapElementInfo elem in _itemInfo)
484 if (elem.IsTextElement) return elem;
485 return null;
486 }
487
488 public string GetSchemaArrayName ()
489 {
490 XmlTypeMapElementInfo einfo = (XmlTypeMapElementInfo) _itemInfo[0];
491 if (einfo.MappedType != null) return TypeTranslator.GetArrayName (einfo.MappedType.XmlType);
492 else return TypeTranslator.GetArrayName (einfo.TypeData.XmlType);
493 }
494
495 public void GetArrayType (int itemCount, out string localName, out string ns)
496 {
497 string arrayDim;
498 if (itemCount != -1) arrayDim = "[" + itemCount + "]";
499 else arrayDim = "[]";
500
501 XmlTypeMapElementInfo info = (XmlTypeMapElementInfo) _itemInfo[0];
502 if (info.TypeData.SchemaType == SchemaTypes.Array)
503 {
504 string nm;
505 ((ListMap)info.MappedType.ObjectMap).GetArrayType (-1, out nm, out ns);
506 localName = nm + arrayDim;
507 }
508 else
509 {
510 if (info.MappedType != null)
511 {
512 localName = info.MappedType.XmlType + arrayDim;
513 ns = info.MappedType.Namespace;
514 }
515 else
516 {
517 localName = info.TypeData.XmlType + arrayDim;
518 ns = info.DataTypeNamespace;
519 }
520 }
521 }
522
523 public override bool Equals (object other)
524 {
525 ListMap lmap = other as ListMap;
526 if (lmap == null) return false;
527
528 if (_itemInfo.Count != lmap._itemInfo.Count) return false;
529 for (int n=0; n<_itemInfo.Count; n++)
530 if (!_itemInfo[n].Equals (lmap._itemInfo[n])) return false;
531 return true;
532 }
533
534 public override int GetHashCode ()
535 {
536 return base.GetHashCode ();
537 }
538 }
539
540 internal class EnumMap: ObjectMap
541 {
542 EnumMapMember[] _members;
543 bool _isFlags;
544
545 public class EnumMapMember
546 {
547 string _xmlName;
548 string _enumName;
549 string _documentation;
550
551 public EnumMapMember (string xmlName, string enumName)
552 {
553 _xmlName = xmlName;
554 _enumName = enumName;
555 }
556
557 public string XmlName
558 {
559 get { return _xmlName; }
560 }
561
562 public string EnumName
563 {
564 get { return _enumName; }
565 }
566
567 public string Documentation
568 {
569 get { return _documentation; }
570 set { _documentation = value; }
571 }
572 }
573
574 public EnumMap (EnumMapMember[] members, bool isFlags)
575 {
576 _members = members;
577 _isFlags = isFlags;
578 }
579
580 public bool IsFlags
581 {
582 get { return _isFlags; }
583 }
584
585 public EnumMapMember[] Members
586 {
587 get { return _members; }
588 }
589
590 public string GetXmlName (object enumValue)
591 {
592 string enumName = enumValue.ToString();
593
594 if (_isFlags && enumName.IndexOf (',') != -1)
595 {
596 System.Text.StringBuilder sb = new System.Text.StringBuilder ();
597 string[] enumNames = enumValue.ToString().Split (',');
598 foreach (string name in enumNames)
599 {
600 string tname = name.Trim();
601 foreach (EnumMapMember mem in _members)
602 if (mem.EnumName == tname) {
603 sb.Append (mem.XmlName).Append (' ');
604 break;
605 }
606 }
607 sb.Remove (sb.Length-1, 1);
608 return sb.ToString ();
609 }
610
611 foreach (EnumMapMember mem in _members)
612 if (mem.EnumName == enumName) return mem.XmlName;
613
614 return Convert.ToInt64(enumValue).ToString(CultureInfo.InvariantCulture);
615 }
616
617 public string GetEnumName (string xmlName)
618 {
619 if (_isFlags && xmlName.Length == 0)
620 return "0";
621
622 if (_isFlags && xmlName.Trim().IndexOf (' ') != -1)
623 {
624 System.Text.StringBuilder sb = new System.Text.StringBuilder ();
625 string[] enumNames = xmlName.ToString().Split (' ');
626 foreach (string name in enumNames)
627 {
628 if (name == string.Empty) continue;
629 string foundEnumValue = null;
630 foreach (EnumMapMember mem in _members)
631 if (mem.XmlName == name) { foundEnumValue = mem.EnumName; break; }
632
633 if (foundEnumValue != null) sb.Append (foundEnumValue).Append (',');
634 else return null;
635 }
636 sb.Remove (sb.Length-1, 1);
637 return sb.ToString ();
638 }
639
640 foreach (EnumMapMember mem in _members)
641 if (mem.XmlName == xmlName) return mem.EnumName;
642
643 return null;
644 }
645 }
646 }
Mirror of the official Mono project git repository