The Labs \ Source Viewer \ SSCLI \ System.Xml.Serialization \ XmlAttributes

  1. //------------------------------------------------------------------------------
  2. // <copyright file="XmlAttributes.cs" company="Microsoft">
  3. //
  4. // Copyright (c) 2006 Microsoft Corporation. All rights reserved.
  5. //
  6. // The use and distribution terms for this software are contained in the file
  7. // named license.txt, which can be found in the root of this distribution.
  8. // By using this software in any fashion, you are agreeing to be bound by the
  9. // terms of this license.
  10. //
  11. // You must not remove this notice, or any other, from this software.
  12. //
  13. // </copyright>
  14. // <owner current="true" primary="true">ElenaK</owner>
  15. //------------------------------------------------------------------------------
  16. namespace System.Xml.Serialization
  17. {
  18.     using System;
  19.     using System.Reflection;
  20.     using System.Collections;
  21.     using System.ComponentModel;
  22.    
  23.     internal enum XmlAttributeFlags
  24.     {
  25.         Enum = 1,
  26.         Array = 2,
  27.         Text = 4,
  28.         ArrayItems = 8,
  29.         Elements = 16,
  30.         Attribute = 32,
  31.         Root = 64,
  32.         Type = 128,
  33.         AnyElements = 256,
  34.         AnyAttribute = 512,
  35.         ChoiceIdentifier = 1024,
  36.         XmlnsDeclarations = 2048
  37.     }
  38.    
  39.     /// <include file='doc\XmlAttributes.uex' path='docs/doc[@for="XmlAttributes"]/*' />
  40.     /// <devdoc>
  41.     /// <para>[To be supplied.]</para>
  42.     /// </devdoc>
  43.     public class XmlAttributes
  44.     {
  45.         XmlElementAttributes xmlElements = new XmlElementAttributes();
  46.         XmlArrayItemAttributes xmlArrayItems = new XmlArrayItemAttributes();
  47.         XmlAnyElementAttributes xmlAnyElements = new XmlAnyElementAttributes();
  48.         XmlArrayAttribute xmlArray;
  49.         XmlAttributeAttribute xmlAttribute;
  50.         XmlTextAttribute xmlText;
  51.         XmlEnumAttribute xmlEnum;
  52.         bool xmlIgnore;
  53.         bool xmlns;
  54.         object xmlDefaultValue = null;
  55.         XmlRootAttribute xmlRoot;
  56.         XmlTypeAttribute xmlType;
  57.         XmlAnyAttributeAttribute xmlAnyAttribute;
  58.         XmlChoiceIdentifierAttribute xmlChoiceIdentifier;
  59.         static Type ignoreAttributeType;
  60.        
  61.        
  62.         /// <include file='doc\XmlAttributes.uex' path='docs/doc[@for="XmlAttributes.XmlAttributes"]/*' />
  63.         /// <devdoc>
  64.         /// <para>[To be supplied.]</para>
  65.         /// </devdoc>
  66.         public XmlAttributes()
  67.         {
  68.         }
  69.        
  70.         internal XmlAttributeFlags XmlFlags {
  71.             get {
  72.                 XmlAttributeFlags flags = 0;
  73.                 if (xmlElements.Count > 0)
  74.                     flags |= XmlAttributeFlags.Elements;
  75.                 if (xmlArrayItems.Count > 0)
  76.                     flags |= XmlAttributeFlags.ArrayItems;
  77.                 if (xmlAnyElements.Count > 0)
  78.                     flags |= XmlAttributeFlags.AnyElements;
  79.                 if (xmlArray != null)
  80.                     flags |= XmlAttributeFlags.Array;
  81.                 if (xmlAttribute != null)
  82.                     flags |= XmlAttributeFlags.Attribute;
  83.                 if (xmlText != null)
  84.                     flags |= XmlAttributeFlags.Text;
  85.                 if (xmlEnum != null)
  86.                     flags |= XmlAttributeFlags.Enum;
  87.                 if (xmlRoot != null)
  88.                     flags |= XmlAttributeFlags.Root;
  89.                 if (xmlType != null)
  90.                     flags |= XmlAttributeFlags.Type;
  91.                 if (xmlAnyAttribute != null)
  92.                     flags |= XmlAttributeFlags.AnyAttribute;
  93.                 if (xmlChoiceIdentifier != null)
  94.                     flags |= XmlAttributeFlags.ChoiceIdentifier;
  95.                 if (xmlns)
  96.                     flags |= XmlAttributeFlags.XmlnsDeclarations;
  97.                 return flags;
  98.             }
  99.         }
  100.        
  101.         private static Type IgnoreAttribute {
  102.             get {
  103.                 if (ignoreAttributeType == null) {
  104.                     ignoreAttributeType = typeof(object).Assembly.GetType("System.XmlIgnoreMemberAttribute");
  105.                     if (ignoreAttributeType == null) {
  106.                         ignoreAttributeType = typeof(XmlIgnoreAttribute);
  107.                     }
  108.                 }
  109.                 return ignoreAttributeType;
  110.             }
  111.         }
  112.        
  113.         /// <include file='doc\XmlAttributes.uex' path='docs/doc[@for="XmlAttributes.XmlAttributes1"]/*' />
  114.         /// <devdoc>
  115.         /// <para>[To be supplied.]</para>
  116.         /// </devdoc>
  117.         public XmlAttributes(ICustomAttributeProvider provider)
  118.         {
  119.             object[] attrs = provider.GetCustomAttributes(false);
  120.            
  121.             // most generic <any/> matches everithig
  122.             XmlAnyElementAttribute wildcard = null;
  123.             for (int i = 0; i < attrs.Length; i++) {
  124.                 if (attrs[i] is XmlIgnoreAttribute || attrs[i] is ObsoleteAttribute || attrs[i].GetType() == IgnoreAttribute) {
  125.                     xmlIgnore = true;
  126.                     break;
  127.                 }
  128.                 else if (attrs[i] is XmlElementAttribute) {
  129.                     this.xmlElements.Add((XmlElementAttribute)attrs[i]);
  130.                 }
  131.                 else if (attrs[i] is XmlArrayItemAttribute) {
  132.                     this.xmlArrayItems.Add((XmlArrayItemAttribute)attrs[i]);
  133.                 }
  134.                 else if (attrs[i] is XmlAnyElementAttribute) {
  135.                     XmlAnyElementAttribute any = (XmlAnyElementAttribute)attrs[i];
  136.                     if ((any.Name == null || any.Name.Length == 0) && any.NamespaceSpecified && any.Namespace == null) {
  137.                         // ignore duplicate wildcards
  138.                         wildcard = any;
  139.                     }
  140.                     else {
  141.                         this.xmlAnyElements.Add((XmlAnyElementAttribute)attrs[i]);
  142.                     }
  143.                 }
  144.                 else if (attrs[i] is DefaultValueAttribute) {
  145.                     this.xmlDefaultValue = ((DefaultValueAttribute)attrs[i]).Value;
  146.                 }
  147.                 else if (attrs[i] is XmlAttributeAttribute) {
  148.                     this.xmlAttribute = (XmlAttributeAttribute)attrs[i];
  149.                 }
  150.                 else if (attrs[i] is XmlArrayAttribute) {
  151.                     this.xmlArray = (XmlArrayAttribute)attrs[i];
  152.                 }
  153.                 else if (attrs[i] is XmlTextAttribute) {
  154.                     this.xmlText = (XmlTextAttribute)attrs[i];
  155.                 }
  156.                 else if (attrs[i] is XmlEnumAttribute) {
  157.                     this.xmlEnum = (XmlEnumAttribute)attrs[i];
  158.                 }
  159.                 else if (attrs[i] is XmlRootAttribute) {
  160.                     this.xmlRoot = (XmlRootAttribute)attrs[i];
  161.                 }
  162.                 else if (attrs[i] is XmlTypeAttribute) {
  163.                     this.xmlType = (XmlTypeAttribute)attrs[i];
  164.                 }
  165.                 else if (attrs[i] is XmlAnyAttributeAttribute) {
  166.                     this.xmlAnyAttribute = (XmlAnyAttributeAttribute)attrs[i];
  167.                 }
  168.                 else if (attrs[i] is XmlChoiceIdentifierAttribute) {
  169.                     this.xmlChoiceIdentifier = (XmlChoiceIdentifierAttribute)attrs[i];
  170.                 }
  171.                 else if (attrs[i] is XmlNamespaceDeclarationsAttribute) {
  172.                     this.xmlns = true;
  173.                 }
  174.             }
  175.             if (xmlIgnore) {
  176.                 this.xmlElements.Clear();
  177.                 this.xmlArrayItems.Clear();
  178.                 this.xmlAnyElements.Clear();
  179.                 this.xmlDefaultValue = null;
  180.                 this.xmlAttribute = null;
  181.                 this.xmlArray = null;
  182.                 this.xmlText = null;
  183.                 this.xmlEnum = null;
  184.                 this.xmlType = null;
  185.                 this.xmlAnyAttribute = null;
  186.                 this.xmlChoiceIdentifier = null;
  187.                 this.xmlns = false;
  188.             }
  189.             else {
  190.                 if (wildcard != null) {
  191.                     this.xmlAnyElements.Add(wildcard);
  192.                 }
  193.             }
  194.         }
  195.        
  196.         static internal object GetAttr(ICustomAttributeProvider provider, Type attrType)
  197.         {
  198.             object[] attrs = provider.GetCustomAttributes(attrType, false);
  199.             if (attrs.Length == 0)
  200.                 return null;
  201.             return attrs[0];
  202.         }
  203.        
  204.         /// <include file='doc\XmlAttributes.uex' path='docs/doc[@for="XmlAttributes.XmlElements"]/*' />
  205.         /// <devdoc>
  206.         /// <para>[To be supplied.]</para>
  207.         /// </devdoc>
  208.         public XmlElementAttributes XmlElements {
  209.             get { return xmlElements; }
  210.         }
  211.        
  212.         /// <include file='doc\XmlAttributes.uex' path='docs/doc[@for="XmlAttributes.XmlAttribute"]/*' />
  213.         /// <devdoc>
  214.         /// <para>[To be supplied.]</para>
  215.         /// </devdoc>
  216.         public XmlAttributeAttribute XmlAttribute {
  217.             get { return xmlAttribute; }
  218.             set { xmlAttribute = value; }
  219.         }
  220.        
  221.         /// <include file='doc\XmlAttributes.uex' path='docs/doc[@for="XmlAttributes.XmlEnum"]/*' />
  222.         /// <devdoc>
  223.         /// <para>[To be supplied.]</para>
  224.         /// </devdoc>
  225.         public XmlEnumAttribute XmlEnum {
  226.             get { return xmlEnum; }
  227.             set { xmlEnum = value; }
  228.         }
  229.        
  230.         /// <include file='doc\XmlAttributes.uex' path='docs/doc[@for="XmlAttributes.XmlText"]/*' />
  231.         /// <devdoc>
  232.         /// <para>[To be supplied.]</para>
  233.         /// </devdoc>
  234.         public XmlTextAttribute XmlText {
  235.             get { return xmlText; }
  236.             set { xmlText = value; }
  237.         }
  238.        
  239.         /// <include file='doc\XmlAttributes.uex' path='docs/doc[@for="XmlAttributes.XmlArray"]/*' />
  240.         /// <devdoc>
  241.         /// <para>[To be supplied.]</para>
  242.         /// </devdoc>
  243.         public XmlArrayAttribute XmlArray {
  244.             get { return xmlArray; }
  245.             set { xmlArray = value; }
  246.         }
  247.        
  248.         /// <include file='doc\XmlAttributes.uex' path='docs/doc[@for="XmlAttributes.XmlArrayItems"]/*' />
  249.         /// <devdoc>
  250.         /// <para>[To be supplied.]</para>
  251.         /// </devdoc>
  252.         public XmlArrayItemAttributes XmlArrayItems {
  253.             get { return xmlArrayItems; }
  254.         }
  255.        
  256.         /// <include file='doc\XmlAttributes.uex' path='docs/doc[@for="XmlAttributes.XmlDefaultValue"]/*' />
  257.         /// <devdoc>
  258.         /// <para>[To be supplied.]</para>
  259.         /// </devdoc>
  260.         public object XmlDefaultValue {
  261.             get { return xmlDefaultValue; }
  262.             set { xmlDefaultValue = value; }
  263.         }
  264.        
  265.         /// <include file='doc\XmlAttributes.uex' path='docs/doc[@for="XmlAttributes.XmlIgnore"]/*' />
  266.         /// <devdoc>
  267.         /// <para>[To be supplied.]</para>
  268.         /// </devdoc>
  269.         public bool XmlIgnore {
  270.             get { return xmlIgnore; }
  271.             set { xmlIgnore = value; }
  272.         }
  273.        
  274.         /// <include file='doc\XmlAttributes.uex' path='docs/doc[@for="XmlAttributes.XmlType"]/*' />
  275.         /// <devdoc>
  276.         /// <para>[To be supplied.]</para>
  277.         /// </devdoc>
  278.         public XmlTypeAttribute XmlType {
  279.             get { return xmlType; }
  280.             set { xmlType = value; }
  281.         }
  282.        
  283.         /// <include file='doc\XmlAttributes.uex' path='docs/doc[@for="XmlAttributes.XmlRoot"]/*' />
  284.         /// <devdoc>
  285.         /// <para>[To be supplied.]</para>
  286.         /// </devdoc>
  287.         public XmlRootAttribute XmlRoot {
  288.             get { return xmlRoot; }
  289.             set { xmlRoot = value; }
  290.         }
  291.        
  292.         /// <include file='doc\XmlAttributes.uex' path='docs/doc[@for="XmlAttributes.XmlAnyElement"]/*' />
  293.         /// <devdoc>
  294.         /// <para>[To be supplied.]</para>
  295.         /// </devdoc>
  296.         public XmlAnyElementAttributes XmlAnyElements {
  297.             get { return xmlAnyElements; }
  298.         }
  299.        
  300.         /// <include file='doc\XmlAttributes.uex' path='docs/doc[@for="XmlAttributes.XmlAnyAttribute"]/*' />
  301.         /// <devdoc>
  302.         /// <para>[To be supplied.]</para>
  303.         /// </devdoc>
  304.         public XmlAnyAttributeAttribute XmlAnyAttribute {
  305.             get { return xmlAnyAttribute; }
  306.             set { xmlAnyAttribute = value; }
  307.         }
  308.        
  309.         /// <include file='doc\XmlAttributes.uex' path='docs/doc[@for="XmlAttributes.XmlChoiceIdentifier"]/*' />
  310.         public XmlChoiceIdentifierAttribute XmlChoiceIdentifier {
  311.             get { return xmlChoiceIdentifier; }
  312.         }
  313.        
  314.         /// <include file='doc\XmlAttributes.uex' path='docs/doc[@for="XmlAttributes.Xmlns"]/*' />
  315.         /// <devdoc>
  316.         /// <para>[To be supplied.]</para>
  317.         /// </devdoc>
  318.         public bool Xmlns {
  319.             get { return xmlns; }
  320.             set { xmlns = value; }
  321.         }
  322.        
  323.     }
  324. }

Developer Fusion