The Labs \ Source Viewer \ SSCLI \ System.Xml.XPath.DataBinding \ Shape

  1. //------------------------------------------------------------------------------
  2. // <copyright file="Shape.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. //------------------------------------------------------------------------------
  15. #if ENABLEDATABINDING
  16. using System;
  17. using System.Xml;
  18. using System.Xml.Schema;
  19. using System.Xml.XPath;
  20. using System.Collections;
  21. using System.Diagnostics;
  22. using System.ComponentModel;
  23. using System.Text;
  24. namespace System.Xml.XPath.DataBinding
  25. {
  26.     internal enum BindingType
  27.     {
  28.         Text,
  29.         Element,
  30.         Attribute,
  31.         ElementNested,
  32.         Repeat,
  33.         Sequence,
  34.         Choice,
  35.         All
  36.     }
  37.    
  38.     internal sealed class Shape
  39.     {
  40.         string name;
  41.         BindingType bindingType;
  42.         ArrayList particles;
  43.         // XmlSchemaElement or XmlSchemaAttribute
  44.         ArrayList subShapes;
  45.         Shape nestedShape;
  46.         PropertyDescriptor[] propertyDescriptors;
  47.         XmlSchemaElement containerDecl;
  48.        
  49.         static object[] emptyIList = new object[0];
  50.        
  51.         public Shape(string name, BindingType bindingType)
  52.         {
  53.             this.name = name;
  54.             this.bindingType = bindingType;
  55.         }
  56.        
  57.         public string Name {
  58.             get { return this.name; }
  59.             set { this.name = value; }
  60.         }
  61.        
  62.         public BindingType BindingType {
  63.             get { return this.bindingType; }
  64.             set { this.bindingType = value; }
  65.         }
  66.        
  67.         public XmlSchemaElement ContainerDecl {
  68.             get { return this.containerDecl; }
  69.             set { this.containerDecl = value; }
  70.         }
  71.        
  72.         public bool IsNestedTable {
  73.             get {
  74.                 switch (this.BindingType) {
  75.                     case BindingType.ElementNested:
  76.                     case BindingType.Repeat:
  77.                     case BindingType.Sequence:
  78.                     case BindingType.Choice:
  79.                     case BindingType.All:
  80.                         return true;
  81.                     default:
  82.                        
  83.                         return false;
  84.                 }
  85.             }
  86.         }
  87.        
  88.         public bool IsGroup {
  89.             get {
  90.                 switch (this.BindingType) {
  91.                     case BindingType.Sequence:
  92.                     case BindingType.Choice:
  93.                     case BindingType.All:
  94.                         return true;
  95.                     default:
  96.                         return false;
  97.                 }
  98.             }
  99.         }
  100.        
  101.         public XmlSchemaType SchemaType {
  102.             get {
  103.                 switch (this.bindingType) {
  104.                     case BindingType.Text:
  105.                     case BindingType.Element:
  106.                     case BindingType.ElementNested:
  107.                        
  108.                         {
  109.                             Debug.Assert(this.particles.Count == 1);
  110.                             XmlSchemaElement xse = (XmlSchemaElement)this.particles[0];
  111.                             return xse.ElementSchemaType;
  112.                         }
  113.                         break;
  114.                     case BindingType.Attribute:
  115.                        
  116.                        
  117.                         {
  118.                             Debug.Assert(this.particles.Count == 1);
  119.                             XmlSchemaAttribute xsa = (XmlSchemaAttribute)this.particles[0];
  120.                             return xsa.AttributeSchemaType;
  121.                         }
  122.                         break;
  123.                     default:
  124.                        
  125.                         return null;
  126.                 }
  127.             }
  128.         }
  129.        
  130.         public XmlSchemaElement XmlSchemaElement {
  131.             get {
  132.                 switch (this.bindingType) {
  133.                     case BindingType.Text:
  134.                     case BindingType.Element:
  135.                     case BindingType.ElementNested:
  136.                        
  137.                         {
  138.                             Debug.Assert(this.particles.Count == 1);
  139.                             return (XmlSchemaElement)this.particles[0];
  140.                         }
  141.                         break;
  142.                     default:
  143.                        
  144.                         return this.containerDecl;
  145.                 }
  146.             }
  147.         }
  148.        
  149.         public IList Particles {
  150.             get {
  151.                 if (null == this.particles)
  152.                     return emptyIList;
  153.                 return this.particles;
  154.             }
  155.         }
  156.        
  157.         public IList SubShapes {
  158.             get {
  159.                 if (null == this.subShapes)
  160.                     return emptyIList;
  161.                 return this.subShapes;
  162.             }
  163.         }
  164.        
  165.         public Shape SubShape(int i)
  166.         {
  167.             return (Shape)SubShapes[i];
  168.         }
  169.        
  170.         public Shape NestedShape {
  171. //Debug.Assert(this.bindingType == BindingType.ElementNested);
  172.             get { return this.nestedShape; }
  173.             set { this.nestedShape = value; }
  174.         }
  175.        
  176.         public XmlQualifiedName AttributeName {
  177.             get {
  178.                 Debug.Assert(this.bindingType == BindingType.Attribute);
  179.                 XmlSchemaAttribute xsa = (XmlSchemaAttribute)this.particles[0];
  180.                 return xsa.QualifiedName;
  181.             }
  182.         }
  183.        
  184.         public void Clear()
  185.         {
  186.             if (this.subShapes != null) {
  187.                 this.subShapes.Clear();
  188.                 this.subShapes = null;
  189.             }
  190.             if (this.particles != null) {
  191.                 this.particles.Clear();
  192.                 this.particles = null;
  193.             }
  194.         }
  195.        
  196.         public void AddParticle(XmlSchemaElement elem)
  197.         {
  198.             if (null == this.particles)
  199.                 this.particles = new ArrayList();
  200.             Debug.Assert(this.bindingType != BindingType.Attribute);
  201.             this.particles.Add(elem);
  202.         }
  203.        
  204.         public void AddParticle(XmlSchemaAttribute elem)
  205.         {
  206.             Debug.Assert(this.bindingType == BindingType.Attribute);
  207.             Debug.Assert(this.particles == null);
  208.             this.particles = new ArrayList();
  209.             this.particles.Add(elem);
  210.         }
  211.        
  212.         public void AddSubShape(Shape shape)
  213.         {
  214.             if (null == this.subShapes)
  215.                 this.subShapes = new ArrayList();
  216.             this.subShapes.Add(shape);
  217.             foreach (object p in shape.Particles) {
  218.                 XmlSchemaElement xse = p as XmlSchemaElement;
  219.                 if (null != xse)
  220.                     AddParticle(xse);
  221.             }
  222.         }
  223.        
  224.         public void AddAttrShapeAt(Shape shape, int pos)
  225.         {
  226.             if (null == this.subShapes)
  227.                 this.subShapes = new ArrayList();
  228.             this.subShapes.Insert(pos, shape);
  229.         }
  230.        
  231.         public string[] SubShapeNames()
  232.         {
  233.             string[] names = new string[SubShapes.Count];
  234.             for (int i = 0; i < SubShapes.Count; i++)
  235.                 names[i] = this.SubShape(i).Name;
  236.             return names;
  237.         }
  238.        
  239.         public PropertyDescriptor[] PropertyDescriptors {
  240.             get {
  241.                 if (null == this.propertyDescriptors) {
  242.                     PropertyDescriptor[] descs;
  243.                     switch (this.BindingType) {
  244.                         case BindingType.Element:
  245.                         case BindingType.Text:
  246.                         case BindingType.Attribute:
  247.                         case BindingType.Repeat:
  248.                             descs = new PropertyDescriptor[1];
  249.                             descs[0] = new XPathNodeViewPropertyDescriptor(this);
  250.                             break;
  251.                         case BindingType.ElementNested:
  252.                            
  253.                             descs = this.nestedShape.PropertyDescriptors;
  254.                             break;
  255.                         case BindingType.Sequence:
  256.                         case BindingType.Choice:
  257.                         case BindingType.All:
  258.                            
  259.                             descs = new PropertyDescriptor[SubShapes.Count];
  260.                             for (int i = 0; i < descs.Length; i++) {
  261.                                 descs[i] = new XPathNodeViewPropertyDescriptor(this, this.SubShape(i), i);
  262.                             }
  263.                             break;
  264.                         default:
  265.                            
  266.                             throw new NotSupportedException();
  267.                             break;
  268.                     }
  269.                     this.propertyDescriptors = descs;
  270.                 }
  271.                 return this.propertyDescriptors;
  272.             }
  273.         }
  274.        
  275.         public int FindNamedSubShape(string name)
  276.         {
  277.             for (int i = 0; i < SubShapes.Count; i++) {
  278.                 Shape shape = SubShape(i);
  279.                 if (shape.Name == name)
  280.                     return i;
  281.             }
  282.             return -1;
  283.         }
  284.        
  285.         public int FindMatchingSubShape(object particle)
  286.         {
  287.             for (int i = 0; i < SubShapes.Count; i++) {
  288.                 Shape shape = SubShape(i);
  289.                 if (shape.IsParticleMatch(particle))
  290.                     return i;
  291.             }
  292.             return -1;
  293.         }
  294.        
  295.         public bool IsParticleMatch(object particle)
  296.         {
  297.             for (int i = 0; i < this.particles.Count; i++) {
  298.                 if (particle == this.particles[i])
  299.                     return true;
  300.             }
  301.             return false;
  302.         }
  303.        
  304.         #if DEBUG
  305.         public string DebugDump()
  306.         {
  307.             StringBuilder sb = new StringBuilder();
  308.             DebugDump(sb, "");
  309.             return sb.ToString();
  310.         }
  311.         void DebugDump(StringBuilder sb, string indent)
  312.         {
  313.             sb.AppendFormat("{0}{1} '{2}'", indent, this.BindingType.ToString(), this.Name);
  314.             if (this.subShapes != null) {
  315.                 sb.AppendLine(" {");
  316.                 string subindent = String.Concat(indent, " ");
  317.                 foreach (Shape s in this.SubShapes) {
  318.                     s.DebugDump(sb, subindent);
  319.                 }
  320.                 sb.Append(indent);
  321.                 sb.Append('}');
  322.             }
  323.             sb.AppendLine();
  324.         }
  325.         #endif
  326.     }
  327. }
  328. #endif

Developer Fusion