We need you! We're working hard on the next version of Developer Fusion - Let us know what you think we should be up to!

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

SSCLI
  1. //------------------------------------------------------------------------------
  2. // <copyright file="Mappings.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. //------------------------------------------------------------------------------
  17. namespace System.Xml.Serialization
  18. {
  19.    
  20.     using System.Reflection;
  21.     using System.Collections;
  22.     using System.Xml.Schema;
  23.     using System;
  24.     using System.Text;
  25.     using System.ComponentModel;
  26.     using System.Xml;
  27.     using System.CodeDom.Compiler;
  28.    
  29.     // These classes represent a mapping between classes and a particular XML format.
  30.     // There are two class of mapping information: accessors (such as elements and
  31.     // attributes), and mappings (which specify the type of an accessor).
  32.    
  33.     internal abstract class Accessor
  34.     {
  35.         string name;
  36.         object defaultValue = null;
  37.         string ns;
  38.         TypeMapping mapping;
  39.         bool any;
  40.         string anyNs;
  41.         bool topLevelInSchema;
  42.         bool isFixed;
  43.         bool isOptional;
  44.         XmlSchemaForm form = XmlSchemaForm.None;
  45.        
  46.         internal Accessor()
  47.         {
  48.         }
  49.        
  50.         internal TypeMapping Mapping {
  51.             get { return mapping; }
  52.             set { mapping = value; }
  53.         }
  54.        
  55.         internal object Default {
  56.             get { return defaultValue; }
  57.             set { defaultValue = value; }
  58.         }
  59.        
  60.         internal bool HasDefault {
  61.             get { return defaultValue != null && defaultValue != DBNull.Value; }
  62.         }
  63.        
  64.         internal virtual string Name {
  65.             get { return name == null ? string.Empty : name; }
  66.             set { name = value; }
  67.         }
  68.        
  69.         internal bool Any {
  70.             get { return any; }
  71.             set { any = value; }
  72.         }
  73.        
  74.         internal string AnyNamespaces {
  75.             get { return anyNs; }
  76.             set { anyNs = value; }
  77.         }
  78.        
  79.         internal string Namespace {
  80.             get { return ns; }
  81.             set { ns = value; }
  82.         }
  83.        
  84.         internal XmlSchemaForm Form {
  85.             get { return form; }
  86.             set { form = value; }
  87.         }
  88.        
  89.         internal bool IsFixed {
  90.             get { return isFixed; }
  91.             set { isFixed = value; }
  92.         }
  93.        
  94.         internal bool IsOptional {
  95.             get { return isOptional; }
  96.             set { isOptional = value; }
  97.         }
  98.        
  99.         internal bool IsTopLevelInSchema {
  100.             get { return topLevelInSchema; }
  101.             set { topLevelInSchema = value; }
  102.         }
  103.        
  104.         static internal string EscapeName(string name)
  105.         {
  106.             if (name == null || name.Length == 0)
  107.                 return name;
  108.             return XmlConvert.EncodeLocalName(name);
  109.         }
  110.        
  111.         static internal string EscapeQName(string name)
  112.         {
  113.             if (name == null || name.Length == 0)
  114.                 return name;
  115.             int colon = name.LastIndexOf(':');
  116.             if (colon < 0)
  117.                 return XmlConvert.EncodeLocalName(name);
  118.             else {
  119.                 if (colon == 0 || colon == name.Length - 1)
  120.                     throw new ArgumentException(Res.GetString(Res.Xml_InvalidNameChars, name), "name");
  121.                 return new XmlQualifiedName(XmlConvert.EncodeLocalName(name.Substring(colon + 1)), XmlConvert.EncodeLocalName(name.Substring(0, colon))).ToString();
  122.             }
  123.         }
  124.        
  125.         static internal string UnescapeName(string name)
  126.         {
  127.             return XmlConvert.DecodeName(name);
  128.         }
  129.        
  130.         internal string ToString(string defaultNs)
  131.         {
  132.             if (Any) {
  133.                 return (Namespace == null ? "##any" : Namespace) + ":" + Name;
  134.             }
  135.             else {
  136.                 return Namespace == defaultNs ? Name : Namespace + ":" + Name;
  137.             }
  138.         }
  139.     }
  140.    
  141.     internal class ElementAccessor : Accessor
  142.     {
  143.         bool nullable;
  144.         bool isSoap;
  145.         bool unbounded = false;
  146.        
  147.         internal bool IsSoap {
  148.             get { return isSoap; }
  149.             set { isSoap = value; }
  150.         }
  151.        
  152.         internal bool IsNullable {
  153.             get { return nullable; }
  154.             set { nullable = value; }
  155.         }
  156.        
  157.         internal bool IsUnbounded {
  158.             get { return unbounded; }
  159.             set { unbounded = value; }
  160.         }
  161.        
  162.         internal ElementAccessor Clone()
  163.         {
  164.             ElementAccessor newAccessor = new ElementAccessor();
  165.             newAccessor.nullable = this.nullable;
  166.             newAccessor.IsTopLevelInSchema = this.IsTopLevelInSchema;
  167.             newAccessor.Form = this.Form;
  168.             newAccessor.isSoap = this.isSoap;
  169.             newAccessor.Name = this.Name;
  170.             newAccessor.Default = this.Default;
  171.             newAccessor.Namespace = this.Namespace;
  172.             newAccessor.Mapping = this.Mapping;
  173.             newAccessor.Any = this.Any;
  174.            
  175.             return newAccessor;
  176.         }
  177.     }
  178.    
  179.     internal class ChoiceIdentifierAccessor : Accessor
  180.     {
  181.         string memberName;
  182.         string[] memberIds;
  183.        
  184.         internal string MemberName {
  185.             get { return memberName; }
  186.             set { memberName = value; }
  187.         }
  188.        
  189.         internal string[] MemberIds {
  190.             get { return memberIds; }
  191.             set { memberIds = value; }
  192.         }
  193.        
  194.     }
  195.    
  196.     internal class TextAccessor : Accessor
  197.     {
  198.     }
  199.    
  200.     internal class XmlnsAccessor : Accessor
  201.     {
  202.     }
  203.    
  204.     internal class AttributeAccessor : Accessor
  205.     {
  206.         bool isSpecial;
  207.         bool isList;
  208.        
  209.         internal bool IsSpecialXmlNamespace {
  210.             get { return isSpecial; }
  211.         }
  212.        
  213.         internal bool IsList {
  214.             get { return isList; }
  215.             set { isList = value; }
  216.         }
  217.        
  218.         internal void CheckSpecial()
  219.         {
  220.             int colon = Name.LastIndexOf(':');
  221.            
  222.             if (colon >= 0) {
  223.                 if (!Name.StartsWith("xml:", StringComparison.Ordinal)) {
  224.                     throw new InvalidOperationException(Res.GetString(Res.Xml_InvalidNameChars, Name));
  225.                 }
  226.                 Name = Name.Substring("xml:".Length);
  227.                 Namespace = XmlReservedNs.NsXml;
  228.                 isSpecial = true;
  229.             }
  230.             else {
  231.                 if (Namespace == XmlReservedNs.NsXml) {
  232.                     isSpecial = true;
  233.                 }
  234.                 else {
  235.                     isSpecial = false;
  236.                 }
  237.             }
  238.             if (isSpecial) {
  239.                 Form = XmlSchemaForm.Qualified;
  240.             }
  241.         }
  242.     }
  243.    
  244.     internal abstract class Mapping
  245.     {
  246.         bool isSoap;
  247.        
  248.         internal Mapping()
  249.         {
  250.         }
  251.        
  252.         internal bool IsSoap {
  253.             get { return isSoap; }
  254.             set { isSoap = value; }
  255.         }
  256.     }
  257.    
  258.     internal abstract class TypeMapping : Mapping
  259.     {
  260.         TypeDesc typeDesc;
  261.         string typeNs;
  262.         string typeName;
  263.         bool referencedByElement;
  264.         bool referencedByTopLevelElement;
  265.         bool includeInSchema = true;
  266.         bool reference = false;
  267.        
  268.         internal bool ReferencedByTopLevelElement {
  269.             get { return referencedByTopLevelElement; }
  270.             set { referencedByTopLevelElement = value; }
  271.         }
  272.        
  273.         internal bool ReferencedByElement {
  274.             get { return referencedByElement || referencedByTopLevelElement; }
  275.             set { referencedByElement = value; }
  276.         }
  277.         internal string Namespace {
  278.             get { return typeNs; }
  279.             set { typeNs = value; }
  280.         }
  281.        
  282.         internal string TypeName {
  283.             get { return typeName; }
  284.             set { typeName = value; }
  285.         }
  286.        
  287.         internal TypeDesc TypeDesc {
  288.             get { return typeDesc; }
  289.             set { typeDesc = value; }
  290.         }
  291.        
  292.         internal bool IncludeInSchema {
  293.             get { return includeInSchema; }
  294.             set { includeInSchema = value; }
  295.         }
  296.        
  297.         internal virtual bool IsList {
  298.             get { return false; }
  299.             set { }
  300.         }
  301.        
  302.         internal bool IsReference {
  303.             get { return reference; }
  304.             set { reference = value; }
  305.         }
  306.        
  307.         internal bool IsAnonymousType {
  308.             get { return typeName == null || typeName.Length == 0; }
  309.         }
  310.        
  311.         internal virtual string DefaultElementName {
  312.             get { return IsAnonymousType ? XmlConvert.EncodeLocalName(typeDesc.Name) : typeName; }
  313.         }
  314.     }
  315.    
  316.     internal class PrimitiveMapping : TypeMapping
  317.     {
  318.         bool isList;
  319.        
  320.         internal override bool IsList {
  321.             get { return isList; }
  322.             set { isList = value; }
  323.         }
  324.     }
  325.    
  326.     internal class NullableMapping : TypeMapping
  327.     {
  328.         TypeMapping baseMapping;
  329.        
  330.         internal TypeMapping BaseMapping {
  331.             get { return baseMapping; }
  332.             set { baseMapping = value; }
  333.         }
  334.        
  335.         internal override string DefaultElementName {
  336.             get { return BaseMapping.DefaultElementName; }
  337.         }
  338.     }
  339.    
  340.     internal class ArrayMapping : TypeMapping
  341.     {
  342.         ElementAccessor[] elements;
  343.         ElementAccessor[] sortedElements;
  344.         ArrayMapping next;
  345.         StructMapping topLevelMapping;
  346.        
  347.         internal ElementAccessor[] Elements {
  348.             get { return elements; }
  349.             set {
  350.                 elements = value;
  351.                 sortedElements = null;
  352.             }
  353.         }
  354.        
  355.         internal ElementAccessor[] ElementsSortedByDerivation {
  356.             get {
  357.                 if (sortedElements != null)
  358.                     return sortedElements;
  359.                 if (elements == null)
  360.                     return null;
  361.                 sortedElements = new ElementAccessor[elements.Length];
  362.                 Array.Copy(elements, 0, sortedElements, 0, elements.Length);
  363.                 AccessorMapping.SortMostToLeastDerived(sortedElements);
  364.                 return sortedElements;
  365.             }
  366.         }
  367.        
  368.        
  369.         internal ArrayMapping Next {
  370.             get { return next; }
  371.             set { next = value; }
  372.         }
  373.        
  374.         internal StructMapping TopLevelMapping {
  375.             get { return topLevelMapping; }
  376.             set { topLevelMapping = value; }
  377.         }
  378.     }
  379.    
  380.     internal class EnumMapping : PrimitiveMapping
  381.     {
  382.         ConstantMapping[] constants;
  383.         bool isFlags;
  384.        
  385.         internal bool IsFlags {
  386.             get { return isFlags; }
  387.             set { isFlags = value; }
  388.         }
  389.        
  390.         internal ConstantMapping[] Constants {
  391.             get { return constants; }
  392.             set { constants = value; }
  393.         }
  394.     }
  395.    
  396.     internal class ConstantMapping : Mapping
  397.     {
  398.         string xmlName;
  399.         string name;
  400.         long value;
  401.        
  402.         internal string XmlName {
  403.             get { return xmlName == null ? string.Empty : xmlName; }
  404.             set { xmlName = value; }
  405.         }
  406.        
  407.         internal string Name {
  408.             get { return name == null ? string.Empty : name; }
  409.             set { this.name = value; }
  410.         }
  411.        
  412.         internal long Value {
  413.             get { return value; }
  414.             set { this.value = value; }
  415.         }
  416.     }
  417.    
  418.     internal class StructMapping : TypeMapping, INameScope
  419.     {
  420.         MemberMapping[] members;
  421.         StructMapping baseMapping;
  422.         StructMapping derivedMappings;
  423.         StructMapping nextDerivedMapping;
  424.         MemberMapping xmlnsMember = null;
  425.         bool hasSimpleContent;
  426.         bool openModel;
  427.         NameTable elements;
  428.         NameTable attributes;
  429.         CodeIdentifiers scope;
  430.        
  431.         internal StructMapping BaseMapping {
  432.             get { return baseMapping; }
  433.             set {
  434.                 baseMapping = value;
  435.                 if (!IsAnonymousType && baseMapping != null) {
  436.                     nextDerivedMapping = baseMapping.derivedMappings;
  437.                     baseMapping.derivedMappings = this;
  438.                 }
  439.             }
  440.         }
  441.        
  442.         internal StructMapping DerivedMappings {
  443.             get { return derivedMappings; }
  444.         }
  445.        
  446.         internal NameTable LocalElements {
  447.             get {
  448.                 if (elements == null)
  449.                     elements = new NameTable();
  450.                 return elements;
  451.             }
  452.         }
  453.         internal NameTable LocalAttributes {
  454.             get {
  455.                 if (attributes == null)
  456.                     attributes = new NameTable();
  457.                 return attributes;
  458.             }
  459.         }
  460.         object INameScope.this[string name, string ns]
  461.         {
  462.             get {
  463.                 object named = LocalElements[name, ns];
  464.                 if (named != null)
  465.                     return named;
  466.                 if (baseMapping != null)
  467.                     return ((INameScope)baseMapping)[name, ns];
  468.                 return null;
  469.             }
  470.             set { LocalElements[name, ns] = value; }
  471.         }
  472.         internal StructMapping NextDerivedMapping {
  473.             get { return nextDerivedMapping; }
  474.         }
  475.        
  476.         internal bool HasSimpleContent {
  477.             get { return hasSimpleContent; }
  478.         }
  479.        
  480.         internal bool HasXmlnsMember {
  481.             get {
  482.                 StructMapping mapping = this;
  483.                 while (mapping != null) {
  484.                     if (mapping.XmlnsMember != null)
  485.                         return true;
  486.                     mapping = mapping.BaseMapping;
  487.                 }
  488.                 return false;
  489.             }
  490.         }
  491.        
  492.         internal MemberMapping[] Members {
  493.             get { return members; }
  494.             set { members = value; }
  495.         }
  496.        
  497.         internal MemberMapping XmlnsMember {
  498.             get { return xmlnsMember; }
  499.             set { xmlnsMember = value; }
  500.         }
  501.        
  502.         internal bool IsOpenModel {
  503.             get { return openModel; }
  504.             set { openModel = value; }
  505.         }
  506.        
  507.         internal CodeIdentifiers Scope {
  508.             get {
  509.                 if (scope == null)
  510.                     scope = new CodeIdentifiers();
  511.                 return scope;
  512.             }
  513.             set { scope = value; }
  514.         }
  515.        
  516.         internal MemberMapping FindDeclaringMapping(MemberMapping member, out StructMapping declaringMapping, string parent)
  517.         {
  518.             declaringMapping = null;
  519.             if (BaseMapping != null) {
  520.                 MemberMapping baseMember = BaseMapping.FindDeclaringMapping(member, out declaringMapping, parent);
  521.                 if (baseMember != null)
  522.                     return baseMember;
  523.             }
  524.             if (members == null)
  525.                 return null;
  526.            
  527.             for (int i = 0; i < members.Length; i++) {
  528.                 if (members[i].Name == member.Name) {
  529.                     if (members[i].TypeDesc != member.TypeDesc)
  530.                         throw new InvalidOperationException(Res.GetString(Res.XmlHiddenMember, parent, member.Name, member.TypeDesc.FullName, this.TypeName, members[i].Name, members[i].TypeDesc.FullName));
  531.                     else if (!members[i].Match(member)) {
  532.                         throw new InvalidOperationException(Res.GetString(Res.XmlInvalidXmlOverride, parent, member.Name, this.TypeName, members[i].Name));
  533.                     }
  534.                     declaringMapping = this;
  535.                     return members[i];
  536.                 }
  537.             }
  538.             return null;
  539.         }
  540.         internal bool Declares(MemberMapping member, string parent)
  541.         {
  542.             StructMapping m;
  543.             return (FindDeclaringMapping(member, out m, parent) != null);
  544.         }
  545.        
  546.         internal void SetContentModel(TextAccessor text, bool hasElements)
  547.         {
  548.             if (BaseMapping == null || BaseMapping.TypeDesc.IsRoot) {
  549.                 hasSimpleContent = !hasElements && text != null && !text.Mapping.IsList;
  550.             }
  551.             else if (BaseMapping.HasSimpleContent) {
  552.                 if (text != null || hasElements) {
  553.                     // we can only extent a simleContent type with attributes
  554.                     throw new InvalidOperationException(Res.GetString(Res.XmlIllegalSimpleContentExtension, TypeDesc.FullName, BaseMapping.TypeDesc.FullName));
  555.                 }
  556.                 else {
  557.                     hasSimpleContent = true;
  558.                 }
  559.             }
  560.             else {
  561.                 hasSimpleContent = false;
  562.             }
  563.             if (!hasSimpleContent && text != null && !text.Mapping.TypeDesc.CanBeTextValue) {
  564.                 throw new InvalidOperationException(Res.GetString(Res.XmlIllegalTypedTextAttribute, TypeDesc.FullName, text.Name, text.Mapping.TypeDesc.FullName));
  565.             }
  566.         }
  567.        
  568.         internal bool HasElements {
  569.             get { return elements != null && elements.Values.Count > 0; }
  570.         }
  571.        
  572.         internal bool HasExplicitSequence()
  573.         {
  574.             if (members != null) {
  575.                 for (int i = 0; i < members.Length; i++) {
  576.                     if (members[i].IsParticle && members[i].IsSequence) {
  577.                         return true;
  578.                     }
  579.                 }
  580.             }
  581.             return (baseMapping != null && baseMapping.HasExplicitSequence());
  582.         }
  583.        
  584.         internal void SetSequence()
  585.         {
  586.             for (int i = 0; i < members.Length; i++) {
  587.                 if (members[i].IsParticle) {
  588.                     members[i].SequenceId = i;
  589.                 }
  590.             }
  591.             if (baseMapping != null) {
  592.                 baseMapping.SetSequence();
  593.             }
  594.         }
  595.     }
  596.    
  597.     internal abstract class AccessorMapping : Mapping
  598.     {
  599.         TypeDesc typeDesc;
  600.         AttributeAccessor attribute;
  601.         ElementAccessor[] elements;
  602.         ElementAccessor[] sortedElements;
  603.         TextAccessor text;
  604.         ChoiceIdentifierAccessor choiceIdentifier;
  605.         XmlnsAccessor xmlns;
  606.         bool ignore;
  607.        
  608.         internal bool IsAttribute {
  609.             get { return attribute != null; }
  610.         }
  611.        
  612.         internal bool IsText {
  613.             get { return text != null && (elements == null || elements.Length == 0); }
  614.         }
  615.        
  616.         internal bool IsParticle {
  617.             get { return (elements != null && elements.Length > 0); }
  618.         }
  619.        
  620.         internal TypeDesc TypeDesc {
  621.             get { return typeDesc; }
  622.             set { typeDesc = value; }
  623.         }
  624.        
  625.         internal AttributeAccessor Attribute {
  626.             get { return attribute; }
  627.             set { attribute = value; }
  628.         }
  629.        
  630.         internal ElementAccessor[] Elements {
  631.             get { return elements; }
  632.             set {
  633.                 elements = value;
  634.                 sortedElements = null;
  635.             }
  636.         }
  637.        
  638.         static internal void SortMostToLeastDerived(ElementAccessor[] elements)
  639.         {
  640.             Array.Sort(elements, new AccessorComparer());
  641.         }
  642.        
  643.         internal class AccessorComparer : IComparer
  644.         {
  645.             public int Compare(object o1, object o2)
  646.             {
  647.                 if (o1 == o2)
  648.                     return 0;
  649.                 Accessor a1 = (Accessor)o1;
  650.                 Accessor a2 = (Accessor)o2;
  651.                 int w1 = a1.Mapping.TypeDesc.Weight;
  652.                 int w2 = a2.Mapping.TypeDesc.Weight;
  653.                 if (w1 == w2)
  654.                     return 0;
  655.                 if (w1 < w2)
  656.                     return 1;
  657.                 return -1;
  658.             }
  659.         }
  660.        
  661.         internal ElementAccessor[] ElementsSortedByDerivation {
  662.             get {
  663.                 if (sortedElements != null)
  664.                     return sortedElements;
  665.                 if (elements == null)
  666.                     return null;
  667.                 sortedElements = new ElementAccessor[elements.Length];
  668.                 Array.Copy(elements, 0, sortedElements, 0, elements.Length);
  669.                 SortMostToLeastDerived(sortedElements);
  670.                 return sortedElements;
  671.             }
  672.         }
  673.        
  674.         internal TextAccessor Text {
  675.             get { return text; }
  676.             set { text = value; }
  677.         }
  678.        
  679.         internal ChoiceIdentifierAccessor ChoiceIdentifier {
  680.             get { return choiceIdentifier; }
  681.             set { choiceIdentifier = value; }
  682.         }
  683.        
  684.         internal XmlnsAccessor Xmlns {
  685.             get { return xmlns; }
  686.             set { xmlns = value; }
  687.         }
  688.        
  689.         internal bool Ignore {
  690.             get { return ignore; }
  691.             set { ignore = value; }
  692.         }
  693.        
  694.         internal Accessor Accessor {
  695.             get {
  696.                 if (xmlns != null)
  697.                     return xmlns;
  698.                 if (attribute != null)
  699.                     return attribute;
  700.                 if (elements != null && elements.Length > 0)
  701.                     return elements[0];
  702.                 return text;
  703.             }
  704.         }
  705.        
  706.         static bool IsNeedNullableMember(ElementAccessor element)
  707.         {
  708.             if (element.Mapping is ArrayMapping) {
  709.                 ArrayMapping arrayMapping = (ArrayMapping)element.Mapping;
  710.                 if (arrayMapping.Elements != null && arrayMapping.Elements.Length == 1) {
  711.                     return IsNeedNullableMember(arrayMapping.Elements[0]);
  712.                 }
  713.                 return false;
  714.             }
  715.             else {
  716.                 return element.IsNullable && element.Mapping.TypeDesc.IsValueType;
  717.             }
  718.         }
  719.        
  720.         internal bool IsNeedNullable {
  721.             get {
  722.                 if (xmlns != null)
  723.                     return false;
  724.                 if (attribute != null)
  725.                     return false;
  726.                 if (elements != null && elements.Length == 1) {
  727.                     return IsNeedNullableMember(elements[0]);
  728.                 }
  729.                 return false;
  730.             }
  731.         }
  732.        
  733.         static internal bool ElementsMatch(ElementAccessor[] a, ElementAccessor[] b)
  734.         {
  735.             if (a == null) {
  736.                 if (b == null)
  737.                     return true;
  738.                 return false;
  739.             }
  740.             if (b == null)
  741.                 return false;
  742.             if (a.Length != b.Length)
  743.                 return false;
  744.             for (int i = 0; i < a.Length; i++) {
  745.                 if (a[i].Name != b[i].Name || a[i].Namespace != b[i].Namespace || a[i].Form != b[i].Form || a[i].IsNullable != b[i].IsNullable)
  746.                     return false;
  747.             }
  748.             return true;
  749.         }
  750.        
  751.         internal bool Match(AccessorMapping mapping)
  752.         {
  753.             if (Elements != null && Elements.Length > 0) {
  754.                 if (!ElementsMatch(Elements, mapping.Elements)) {
  755.                     return false;
  756.                 }
  757.                 if (Text == null) {
  758.                     return (mapping.Text == null);
  759.                 }
  760.             }
  761.     &