?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[LoongArch64] Part-5:add loongarch support in some files for LoongArch64. (#21769)
[mono-project.git] / mcs / class / System.XML / System.Xml.Serialization / XmlTypeMapping.cs
blobf70bd99464b3bda99d20425c731c3396b64d7aaa
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 using System.Xml.Schema;
37 using System.Reflection;
38
39 namespace System.Xml.Serialization
40 {
41 public class XmlTypeMapping : XmlMapping
42 {
43 private string xmlType;
44 private string xmlTypeNamespace;
45 TypeData type;
46 XmlTypeMapping baseMap;
47 bool multiReferenceType = false;
48 bool isSimpleType;
49 string documentation;
50 bool includeInSchema;
51 bool isNullable = true;
52 bool isAny;
53
54 ArrayList _derivedTypes = new ArrayList();
55
56 internal XmlTypeMapping(string elementName, string ns, TypeData typeData, string xmlType, string xmlTypeNamespace)
57 : base (elementName, ns)
58 {
59 this.type = typeData;
60 this.xmlType = xmlType;
61 this.xmlTypeNamespace = xmlTypeNamespace;
62 }
63
64
65 public string TypeFullName
66 {
67 get { return type.FullTypeName; }
68 }
69
70 public string TypeName
71 {
72 get { return type.TypeName; }
73 }
74
75 public string XsdTypeName
76 {
77 get { return XmlType; }
78 }
79
80 public string XsdTypeNamespace
81 {
82 get { return XmlTypeNamespace; }
83 }
84
85 internal TypeData TypeData
86 {
87 get { return type; }
88 }
89
90 internal string XmlType
91 {
92 get { return xmlType; }
93 set { xmlType = value; }
94 }
95
96 internal string XmlTypeNamespace
97 {
98 get { return xmlTypeNamespace ?? string.Empty; }
99 set { xmlTypeNamespace = value; }
100 }
101
102 internal bool HasXmlTypeNamespace
103 {
104 get { return xmlTypeNamespace != null; }
105 }
106
107 internal ArrayList DerivedTypes
108 {
109 get { return _derivedTypes; }
110 set { _derivedTypes = value; }
111 }
112
113 internal bool MultiReferenceType
114 {
115 get { return multiReferenceType; }
116 set { multiReferenceType = value; }
117 }
118
119 internal XmlTypeMapping BaseMap
120 {
121 get { return baseMap; }
122 set { baseMap = value; }
123 }
124
125 internal bool IsSimpleType
126 {
127 get { return isSimpleType; }
128 set { isSimpleType = value; }
129 }
130
131 internal string Documentation
132 {
133 set { documentation = value; }
134 get { return documentation; }
135 }
136
137 internal bool IncludeInSchema
138 {
139 get { return includeInSchema; }
140 set { includeInSchema = value; }
141 }
142
143 internal bool IsNullable
144 {
145 get { return isNullable; }
146 set { isNullable = value; }
147 }
148
149 internal bool IsAny
150 {
151 get { return isAny; }
152 set { isAny = value; }
153 }
154
155 internal XmlTypeMapping GetRealTypeMap (Type objectType)
156 {
157 if (TypeData.SchemaType == SchemaTypes.Enum)
158 return this;
159
160 // Returns the map for a subtype of this map's type
161 if (TypeData.Type == objectType) return this;
162 for (int n=0; n<_derivedTypes.Count; n++) {
163 XmlTypeMapping map = (XmlTypeMapping) _derivedTypes[n];
164 if (map.TypeData.Type == objectType) return map;
165 }
166
167 return null;
168 }
169
170 internal XmlTypeMapping GetRealElementMap (string name, string ens)
171 {
172 if (xmlType == name && XmlTypeNamespace == ens) return this;
173 foreach (XmlTypeMapping map in _derivedTypes)
174 if (map.xmlType == name && map.XmlTypeNamespace == ens) return map;
175
176 return null;
177 }
178
179 internal void UpdateRoot (XmlQualifiedName qname)
180 {
181 if (qname != null) {
182 this._elementName = qname.Name;
183 this._namespace = qname.Namespace;
184 }
185 }
186 }
187
188
189 // Mapping info for XmlSerializable
190 internal class XmlSerializableMapping : XmlTypeMapping
191 {
192 XmlSchema _schema;
193 XmlSchemaComplexType _schemaType;
194 XmlQualifiedName _schemaTypeName;
195
196 internal XmlSerializableMapping(XmlRootAttribute root, string elementName, string ns, TypeData typeData, string xmlType, string xmlTypeNamespace)
197 : base(elementName, ns, typeData, xmlType, xmlTypeNamespace)
198 {
199 XmlSchemaProviderAttribute schemaProvider = (XmlSchemaProviderAttribute) Attribute.GetCustomAttribute (typeData.Type, typeof (XmlSchemaProviderAttribute));
200
201 if (schemaProvider != null) {
202 _schemaTypeName = XmlQualifiedName.Empty;
203
204 if (schemaProvider.IsAny) {
205 IsAny = true;
206 return;
207 }
208
209 string method = schemaProvider.MethodName;
210 MethodInfo mi = typeData.Type.GetMethod (method, BindingFlags.Static | BindingFlags.Public | BindingFlags.FlattenHierarchy);
211 if (mi == null)
212 throw new InvalidOperationException (String.Format ("Type '{0}' must implement public static method '{1}'", typeData.Type, method));
213 if (!typeof (XmlQualifiedName).IsAssignableFrom (mi.ReturnType) &&
214 // LAMESPEC: it is undocumented. (We don't have to tell users about it in the error message.)
215 // Also do not add such a silly compatibility test to assert that it does not raise an error.
216 !typeof (XmlSchemaComplexType).IsAssignableFrom (mi.ReturnType))
217 throw new InvalidOperationException (String.Format ("Method '{0}' indicated by XmlSchemaProviderAttribute must have its return type as XmlQualifiedName", method));
218 XmlSchemaSet xs = new XmlSchemaSet ();
219 object retVal = mi.Invoke (null, new object [] { xs });
220 if (retVal == null)
221 return;
222
223 if (retVal is XmlSchemaComplexType) {
224 _schemaType = (XmlSchemaComplexType) retVal;
225 if (!_schemaType.QualifiedName.IsEmpty)
226 _schemaTypeName = _schemaType.QualifiedName;
227 else
228 _schemaTypeName = new XmlQualifiedName (xmlType, xmlTypeNamespace);
229 }
230 else if (retVal is XmlQualifiedName) {
231 _schemaTypeName = (XmlQualifiedName)retVal;
232 }
233 else
234 throw new InvalidOperationException (
235 String.Format ("Method {0}.{1}() specified by XmlSchemaProviderAttribute has invalid signature: return type must be compatible with System.Xml.XmlQualifiedName.", typeData.Type.Name, method));
236
237 // defaultNamespace at XmlReflectionImporter takes precedence for Namespace, but not for XsdTypeNamespace.
238 UpdateRoot (new XmlQualifiedName (root != null ? root.ElementName : _schemaTypeName.Name, root != null ? root.Namespace : Namespace ?? _schemaTypeName.Namespace));
239 XmlTypeNamespace = _schemaTypeName.Namespace;
240 XmlType = _schemaTypeName.Name;
241
242 if (!_schemaTypeName.IsEmpty && xs.Count > 0) {
243 XmlSchema [] schemas = new XmlSchema [xs.Count];
244 xs.CopyTo (schemas, 0);
245 _schema = schemas [0];
246 }
247
248 return;
249 }
250
251 IXmlSerializable serializable = (IXmlSerializable)Activator.CreateInstance (typeData.Type, true);
252 try {
253 _schema = serializable.GetSchema();
254 } catch (Exception) {
255 // LAMESPEC: .NET has a bad exception catch and swallows it silently.
256 }
257
258 if (_schema != null)
259 {
260 if (_schema.Id == null || _schema.Id.Length == 0)
261 throw new InvalidOperationException("Schema Id is missing. The schema returned from " + typeData.Type.FullName + ".GetSchema() must have an Id.");
262 }
263 }
264
265 internal XmlSchema Schema
266 {
267 get { return _schema; }
268 }
269
270 internal XmlSchemaType SchemaType {
271 get { return _schemaType; }
272 }
273
274 internal XmlQualifiedName SchemaTypeName {
275 get { return _schemaTypeName; }
276 }
277 }
278
279
280 // Mapping info for classes and structs
281
282 internal class ClassMap: ObjectMap
283 {
284 Hashtable _elements = new Hashtable ();
285 ArrayList _elementMembers;
286 Hashtable _attributeMembers;
287 XmlTypeMapMemberAttribute[] _attributeMembersArray;
288 XmlTypeMapElementInfo[] _elementsByIndex;
289 ArrayList _flatLists;
290 ArrayList _allMembers = new ArrayList ();
291 ArrayList _membersWithDefault;
292 ArrayList _listMembers;
293 XmlTypeMapMemberAnyElement _defaultAnyElement;
294 XmlTypeMapMemberAnyAttribute _defaultAnyAttribute;
295 XmlTypeMapMemberNamespaces _namespaceDeclarations;
296 XmlTypeMapMember _xmlTextCollector;
297 XmlTypeMapMember _returnMember;
298 bool _ignoreMemberNamespace;
299 bool _canBeSimpleType = true;
300 bool? _isOrderDependentMap;
301
302 public void AddMember (XmlTypeMapMember member)
303 {
304 // If GlobalIndex has not been set, set it now
305 if (member.GlobalIndex == -1)
306 member.GlobalIndex = _allMembers.Count;
307
308 _allMembers.Add (member);
309
310 if (!(member.DefaultValue is System.DBNull) && member.DefaultValue != null) {
311 if (_membersWithDefault == null) _membersWithDefault = new ArrayList ();
312 _membersWithDefault.Add (member);
313 }
314
315 if (member.IsReturnValue)
316 _returnMember = member;
317
318 if (member is XmlTypeMapMemberAttribute)
319 {
320 XmlTypeMapMemberAttribute atm = (XmlTypeMapMemberAttribute)member;
321 if (_attributeMembers == null) _attributeMembers = new Hashtable();
322 string key = BuildKey (atm.AttributeName, atm.Namespace, -1);
323 if (_attributeMembers.ContainsKey (key))
324 throw new InvalidOperationException ("The XML attribute named '" + atm.AttributeName + "' from namespace '" + atm.Namespace + "' is already present in the current scope. Use XML attributes to specify another XML name or namespace for the attribute.");
325 member.Index = _attributeMembers.Count;
326 _attributeMembers.Add (key, member);
327 return;
328 }
329 else if (member is XmlTypeMapMemberFlatList)
330 {
331 RegisterFlatList ((XmlTypeMapMemberFlatList)member);
332 }
333 else if (member is XmlTypeMapMemberAnyElement)
334 {
335 XmlTypeMapMemberAnyElement mem = (XmlTypeMapMemberAnyElement) member;
336 if (mem.IsDefaultAny) _defaultAnyElement = mem;
337 if (mem.TypeData.IsListType) RegisterFlatList (mem);
338 }
339 else if (member is XmlTypeMapMemberAnyAttribute)
340 {
341 _defaultAnyAttribute = (XmlTypeMapMemberAnyAttribute) member;
342 return;
343 }
344 else if (member is XmlTypeMapMemberNamespaces)
345 {
346 _namespaceDeclarations = (XmlTypeMapMemberNamespaces) member;
347 return;
348 }
349
350 if (member is XmlTypeMapMemberElement && ((XmlTypeMapMemberElement)member).IsXmlTextCollector)
351 {
352 if (_xmlTextCollector != null) throw new InvalidOperationException ("XmlTextAttribute can only be applied once in a class");
353 _xmlTextCollector = member;
354 }
355
356 if (_elementMembers == null) {
357 _elementMembers = new ArrayList();
358 _elements = new Hashtable();
359 }
360
361 member.Index = _elementMembers.Count;
362 _elementMembers.Add (member);
363
364 ICollection elemsInfo = ((XmlTypeMapMemberElement)member).ElementInfo;
365 foreach (XmlTypeMapElementInfo elem in elemsInfo)
366 {
367 string key = BuildKey (elem.ElementName, elem.Namespace, elem.ExplicitOrder);
368 if (_elements.ContainsKey (key))
369 throw new InvalidOperationException ("The XML element named '" + elem.ElementName + "' from namespace '" + elem.Namespace + "' is already present in the current scope. Use XML attributes to specify another XML name or namespace for the element.");
370 _elements.Add (key, elem);
371 }
372
373 if (member.TypeData.IsListType && member.TypeData.Type != null && !member.TypeData.Type.IsArray) {
374 if (_listMembers == null) _listMembers = new ArrayList ();
375 _listMembers.Add (member);
376 }
377 }
378
379 void RegisterFlatList (XmlTypeMapMemberExpandable member)
380 {
381 if (_flatLists == null) _flatLists = new ArrayList ();
382 member.FlatArrayIndex = _flatLists.Count;
383 _flatLists.Add (member);
384 }
385
386 public XmlTypeMapMemberAttribute GetAttribute (string name, string ns)
387 {
388 if (_attributeMembers == null) return null;
389 return (XmlTypeMapMemberAttribute)_attributeMembers [BuildKey (name,ns, -1)];
390 }
391
392 public XmlTypeMapElementInfo GetElement(string name, string ns, int minimalOrder)
393 {
394 if (_elements == null)
395 return null;
396
397 XmlTypeMapElementInfo selected = null;
398 foreach (XmlTypeMapElementInfo info in _elements.Values) {
399 if (info.ElementName == name && info.Namespace == ns) {
400 if (info.ExplicitOrder < minimalOrder)
401 continue;
402
403 if (selected == null || selected.ExplicitOrder > info.ExplicitOrder) {
404 selected = info;
405 }
406 }
407 }
408
409 return selected;
410 }
411
412 public XmlTypeMapElementInfo GetElement(string name, string ns)
413 {
414 if (_elements == null) return null;
415
416 foreach (XmlTypeMapElementInfo info in _elements.Values)
417 if (info.ElementName == name && info.Namespace == ns)
418 return info;
419
420 return null;
421 }
422
423 public XmlTypeMapElementInfo GetElement (int index)
424 {
425 if (_elements == null) return null;
426
427 if (_elementsByIndex == null)
428 {
429 _elementsByIndex = new XmlTypeMapElementInfo [_elementMembers.Count];
430 foreach (XmlTypeMapMemberElement mem in _elementMembers)
431 {
432 if (mem.ElementInfo.Count != 1)
433 throw new InvalidOperationException ("Read by order only possible for encoded/bare format");
434
435 _elementsByIndex [mem.Index] = (XmlTypeMapElementInfo) mem.ElementInfo [0];
436 }
437 }
438 if (index >= _elementMembers.Count)
439 return null;
440 return _elementsByIndex [index];
441 }
442
443 private string BuildKey (string name, string ns, int explicitOrder)
444 {
445 if (_ignoreMemberNamespace) return name;
446 else return name + " / " + ns + (explicitOrder < 0 ? "" : "/" + explicitOrder);
447 }
448
449 public ICollection AllElementInfos
450 {
451 get { return _elements.Values; }
452 }
453
454
455 public bool IgnoreMemberNamespace
456 {
457 get { return _ignoreMemberNamespace; }
458 set { _ignoreMemberNamespace = value; }
459 }
460
461 public bool IsOrderDependentMap {
462 get {
463 if (_isOrderDependentMap == null) {
464 _isOrderDependentMap = false;
465 foreach (XmlTypeMapElementInfo ei in _elements.Values)
466 if (ei.ExplicitOrder >= 0) {
467 _isOrderDependentMap = true;
468 break;
469 }
470 }
471 return (bool) _isOrderDependentMap;
472 }
473 }
474
475 public XmlTypeMapMember FindMember (string name)
476 {
477 for (int n=0; n<_allMembers.Count; n++)
478 if (((XmlTypeMapMember)_allMembers[n]).Name == name) return (XmlTypeMapMember)_allMembers[n];
479 return null;
480 }
481
482 public XmlTypeMapMemberAnyElement DefaultAnyElementMember
483 {
484 get { return _defaultAnyElement; }
485 }
486
487 public XmlTypeMapMemberAnyAttribute DefaultAnyAttributeMember
488 {
489 get { return _defaultAnyAttribute; }
490 }
491
492 public XmlTypeMapMemberNamespaces NamespaceDeclarations
493 {
494 get { return _namespaceDeclarations; }
495 }
496
497 public ICollection AttributeMembers
498 {
499 get
500 {
501 if (_attributeMembers == null) return null;
502 if (_attributeMembersArray != null) return _attributeMembersArray;
503
504 _attributeMembersArray = new XmlTypeMapMemberAttribute[_attributeMembers.Count];
505 foreach (XmlTypeMapMemberAttribute mem in _attributeMembers.Values)
506 _attributeMembersArray [mem.Index] = mem;
507 return _attributeMembersArray;
508 }
509 }
510
511 public ICollection ElementMembers
512 {
513 get { return _elementMembers; }
514 }
515
516 public ArrayList AllMembers
517 {
518 get { return _allMembers; }
519 }
520
521 public ArrayList FlatLists
522 {
523 get { return _flatLists; }
524 }
525
526 public ArrayList MembersWithDefault
527 {
528 get { return _membersWithDefault; }
529 }
530
531 public ArrayList ListMembers
532 {
533 get { return _listMembers; }
534 }
535
536 public XmlTypeMapMember XmlTextCollector
537 {
538 get { return _xmlTextCollector; }
539 }
540
541 public XmlTypeMapMember ReturnMember
542 {
543 get { return _returnMember; }
544 }
545
546 public XmlQualifiedName SimpleContentBaseType
547 {
548 get
549 {
550 if (!_canBeSimpleType || _elementMembers == null || _elementMembers.Count != 1) return null;
551 XmlTypeMapMemberElement member = (XmlTypeMapMemberElement) _elementMembers[0];
552 if (member.ElementInfo.Count != 1) return null;
553 XmlTypeMapElementInfo einfo = (XmlTypeMapElementInfo) member.ElementInfo[0];
554 if (!einfo.IsTextElement) return null;
555 if (member.TypeData.SchemaType == SchemaTypes.Primitive || member.TypeData.SchemaType == SchemaTypes.Enum)
556 return new XmlQualifiedName (einfo.TypeData.XmlType, einfo.DataTypeNamespace);
557 return null;
558 }
559 }
560
561 public void SetCanBeSimpleType (bool can)
562 {
563 _canBeSimpleType = can;
564 }
565
566 public bool HasSimpleContent
567 {
568 get
569 {
570 return SimpleContentBaseType != null;
571 }
572 }
573
574 }
575
576 // Mapping info for arrays and lists
577
578 internal class ListMap: ObjectMap
579 {
580 XmlTypeMapElementInfoList _itemInfo;
581 bool _gotNestedMapping;
582 XmlTypeMapping _nestedArrayMapping;
583 string _choiceMember;
584
585 public bool IsMultiArray
586 {
587 get
588 {
589 return (NestedArrayMapping != null);
590 }
591 }
592
593 public string ChoiceMember
594 {
595 get { return _choiceMember; }
596 set { _choiceMember = value; }
597 }
598
599 public XmlTypeMapping NestedArrayMapping
600 {
601 get
602 {
603 if (_gotNestedMapping) return _nestedArrayMapping;
604 _gotNestedMapping = true;
605
606 _nestedArrayMapping = ((XmlTypeMapElementInfo)_itemInfo[0]).MappedType;
607
608 if (_nestedArrayMapping == null) return null;
609
610 if (_nestedArrayMapping.TypeData.SchemaType != SchemaTypes.Array) {
611 _nestedArrayMapping = null; return null;
612 }
613
614 foreach (XmlTypeMapElementInfo elem in _itemInfo)
615 if (elem.MappedType != _nestedArrayMapping) {
616 _nestedArrayMapping = null;
617 return null;
618 }
619
620 return _nestedArrayMapping;
621 }
622 }
623
624 public XmlTypeMapElementInfoList ItemInfo
625 {
626
627 get { return _itemInfo; }
628 set { _itemInfo = value; }
629 }
630
631 public XmlTypeMapElementInfo FindElement (object ob, int index, object memberValue)
632 {
633 if (_itemInfo.Count == 1)
634 return (XmlTypeMapElementInfo) _itemInfo[0];
635 else if (_choiceMember != null && index != -1)
636 {
637 Array values = (Array) XmlTypeMapMember.GetValue (ob, _choiceMember);
638 if (values == null || index >= values.Length)
639 throw new InvalidOperationException ("Invalid or missing choice enum value in member '" + _choiceMember + "'.");
640 object val = values.GetValue (index);
641 foreach (XmlTypeMapElementInfo elem in _itemInfo)
642 if (elem.ChoiceValue != null && elem.ChoiceValue.Equals (val))
643 return elem;
644 }
645 else
646 {
647 if (memberValue == null) return null;
648 Type type = memberValue.GetType();
649 XmlTypeMapElementInfo bestMatch = null;
650 foreach (XmlTypeMapElementInfo elem in _itemInfo) {
651 if (elem.TypeData.Type == type)
652 return elem;
653 if (elem.TypeData.Type.IsAssignableFrom (type) &&
654 (bestMatch == null || elem.TypeData.Type.IsAssignableFrom (bestMatch.TypeData.Type)))
655 bestMatch = elem;
656 }
657 return bestMatch;
658 }
659 return null;
660 }
661
662 public XmlTypeMapElementInfo FindElement (string elementName, string ns)
663 {
664 foreach (XmlTypeMapElementInfo elem in _itemInfo)
665 if (elem.ElementName == elementName && elem.Namespace == ns) return elem;
666 return null;
667 }
668
669 public XmlTypeMapElementInfo FindTextElement ()
670 {
671 foreach (XmlTypeMapElementInfo elem in _itemInfo)
672 if (elem.IsTextElement) return elem;
673 return null;
674 }
675
676 public string GetSchemaArrayName ()
677 {
678 XmlTypeMapElementInfo einfo = (XmlTypeMapElementInfo) _itemInfo[0];
679 if (einfo.MappedType != null) return TypeTranslator.GetArrayName (einfo.MappedType.XmlType);
680 else return TypeTranslator.GetArrayName (einfo.TypeData.XmlType);
681 }
682
683 public void GetArrayType (int itemCount, out string localName, out string ns)
684 {
685 string arrayDim;
686 if (itemCount != -1) arrayDim = "[" + itemCount + "]";
687 else arrayDim = "[]";
688
689 XmlTypeMapElementInfo info = (XmlTypeMapElementInfo) _itemInfo[0];
690 if (info.TypeData.SchemaType == SchemaTypes.Array)
691 {
692 string nm;
693 ((ListMap)info.MappedType.ObjectMap).GetArrayType (-1, out nm, out ns);
694 localName = nm + arrayDim;
695 }
696 else
697 {
698 if (info.MappedType != null)
699 {
700 localName = info.MappedType.XmlType + arrayDim;
701 ns = info.MappedType.Namespace;
702 }
703 else
704 {
705 localName = info.TypeData.XmlType + arrayDim;
706 ns = info.DataTypeNamespace;
707 }
708 }
709 }
710
711 public override bool Equals (object other)
712 {
713 ListMap lmap = other as ListMap;
714 if (lmap == null) return false;
715
716 if (_itemInfo.Count != lmap._itemInfo.Count) return false;
717 for (int n=0; n<_itemInfo.Count; n++)
718 if (!_itemInfo[n].Equals (lmap._itemInfo[n])) return false;
719 return true;
720 }
721
722 public override int GetHashCode ()
723 {
724 return base.GetHashCode ();
725 }
726 }
727
728 internal class EnumMap: ObjectMap
729 {
730 readonly EnumMapMember[] _members;
731 readonly bool _isFlags;
732 readonly string[] _enumNames = null;
733 readonly string[] _xmlNames = null;
734 readonly long[] _values = null;
735
736 public class EnumMapMember
737 {
738 readonly string _xmlName;
739 readonly string _enumName;
740 readonly long _value;
741 string _documentation;
742
743 public EnumMapMember (string xmlName, string enumName)
744 : this (xmlName, enumName, 0)
745 {
746 }
747
748 public EnumMapMember (string xmlName, string enumName, long value)
749 {
750 _xmlName = xmlName;
751 _enumName = enumName;
752 _value = value;
753 }
754
755 public string XmlName
756 {
757 get { return _xmlName; }
758 }
759
760 public string EnumName
761 {
762 get { return _enumName; }
763 }
764
765 public long Value
766 {
767 get { return _value; }
768 }
769
770 public string Documentation
771 {
772 get { return _documentation; }
773 set { _documentation = value; }
774 }
775 }
776
777 public EnumMap (EnumMapMember[] members, bool isFlags)
778 {
779 _members = members;
780 _isFlags = isFlags;
781
782 _enumNames = new string[_members.Length];
783 _xmlNames = new string[_members.Length];
784 _values = new long[_members.Length];
785
786 for (int i = 0; i < _members.Length; i++) {
787 EnumMapMember mem = _members[i];
788 _enumNames[i] = mem.EnumName;
789 _xmlNames[i] = mem.XmlName;
790 _values[i] = mem.Value;
791 }
792 }
793
794 public bool IsFlags
795 {
796 get { return _isFlags; }
797 }
798
799 public EnumMapMember[] Members
800 {
801 get { return _members; }
802 }
803
804 public string[] EnumNames
805 {
806 get {
807 return _enumNames;
808 }
809 }
810
811 public string[] XmlNames
812 {
813 get {
814 return _xmlNames;
815 }
816 }
817
818 public long[] Values
819 {
820 get {
821 return _values;
822 }
823 }
824
825 public string GetXmlName (string typeName, object enumValue)
826 {
827 if (enumValue is string) {
828 throw new InvalidCastException ();
829 }
830
831 long value = 0;
832
833 try {
834 value = ((IConvertible) enumValue).ToInt64 (CultureInfo.CurrentCulture);
835 } catch (FormatException) {
836 throw new InvalidCastException ();
837 }
838
839 for (int i = 0; i < Values.Length; i++) {
840 if (Values[i] == value)
841 return XmlNames[i];
842 }
843
844 if (IsFlags && value == 0)
845 return string.Empty;
846
847 string xmlName = string.Empty;
848 if (IsFlags) {
849 xmlName = XmlCustomFormatter.FromEnum (value, XmlNames, Values, typeName);
850 }
851
852 if (xmlName.Length == 0) {
853 throw new InvalidOperationException (string.Format(CultureInfo.CurrentCulture,
854 "'{0}' is not a valid value for {1}.", value, typeName));
855 }
856 return xmlName;
857 }
858
859 public string GetEnumName (string typeName, string xmlName)
860 {
861 if (_isFlags) {
862 xmlName = xmlName.Trim ();
863 if (xmlName.Length == 0)
864 return "0";
865
866 System.Text.StringBuilder sb = new System.Text.StringBuilder ();
867 string[] enumNames = xmlName.Split (null);
868 foreach (string name in enumNames) {
869 if (name == string.Empty) continue;
870 string foundEnumValue = null;
871 for (int i = 0; i < XmlNames.Length; i++)
872 if (XmlNames[i] == name) {
873 foundEnumValue = EnumNames[i];
874 break;
875 }
876
877 if (foundEnumValue != null) {
878 if (sb.Length > 0)
879 sb.Append (',');
880 sb.Append (foundEnumValue);
881 } else {
882 throw new InvalidOperationException (string.Format (CultureInfo.CurrentCulture,
883 "'{0}' is not a valid value for {1}.", name, typeName));
884 }
885 }
886 return sb.ToString ();
887 }
888
889 foreach (EnumMapMember mem in _members)
890 if (mem.XmlName == xmlName) return mem.EnumName;
891
892 return null;
893 }
894 }
895 }
Mirror of the official Mono project git repository