Example #1
0
        public void AddedInner(XElement target)
        {
            SetContext(target);
            if (target.IsTrue("serializable"))
            {
                Indent().WriteLine("[Serializable]");
            }

            var type = target.Attribute("type").Value;

            if (type == "enum")
            {
                // check if [Flags] is present
                var cattrs = target.Element("attributes");
                if (cattrs != null)
                {
                    foreach (var ca in cattrs.Elements("attribute"))
                    {
                        if (ca.GetAttribute("name") == "System.FlagsAttribute")
                        {
                            Indent().WriteLine("[Flags]");
                            break;
                        }
                    }
                }
            }

            Indent().Write("public");

            if (type != "enum")
            {
                bool seal = target.IsTrue("sealed");
                bool abst = target.IsTrue("abstract");
                if (seal && abst)
                {
                    Output.Write(" static");
                }
                else if (seal && type != "struct")
                {
                    Output.Write(" sealed");
                }
                else if (abst && type != "interface")
                {
                    Output.Write(" abstract");
                }
            }

            Output.Write(' ');
            Output.Write(type);
            Output.Write(' ');
            Output.Write(target.GetAttribute("name"));

            var baseclass = target.GetAttribute("base");

            if ((type != "enum") && (type != "struct"))
            {
                if (baseclass != null)
                {
                    if (baseclass == "System.Object")
                    {
                        // while true we do not need to be reminded every time...
                        baseclass = null;
                    }
                    else
                    {
                        Output.Write(" : ");
                        Output.Write(baseclass);
                    }
                }
            }

            // interfaces on enums are "standard" not user provided - so we do not want to show them
            if (type != "enum")
            {
                var i = target.Element("interfaces");
                if (i != null)
                {
                    var interfaces = new List <string> ();
                    foreach (var iface in i.Elements("interface"))
                    {
                        interfaces.Add(icomparer.GetDescription(iface));
                    }
                    Output.Write((baseclass == null) ? " : " : ", ");
                    Output.Write(String.Join(", ", interfaces));
                }
            }

            Output.WriteLine(" {");

            State.Indent++;
            var t = target.Element("constructors");

            if (t != null)
            {
                Indent().WriteLine("// constructors");
                foreach (var ctor in t.Elements("constructor"))
                {
                    ccomparer.Added(ctor, true);
                }
            }

            t = target.Element("fields");
            if (t != null)
            {
                if (type != "enum")
                {
                    Indent().WriteLine("// fields");
                }
                else
                {
                    SetContext(target);
                }
                foreach (var field in t.Elements("field"))
                {
                    fcomparer.Added(field, true);
                }
            }

            t = target.Element("properties");
            if (t != null)
            {
                Indent().WriteLine("// properties");
                foreach (var property in t.Elements("property"))
                {
                    pcomparer.Added(property, true);
                }
            }

            t = target.Element("events");
            if (t != null)
            {
                Indent().WriteLine("// events");
                foreach (var evnt in t.Elements("event"))
                {
                    ecomparer.Added(evnt, true);
                }
            }

            t = target.Element("methods");
            if (t != null)
            {
                Indent().WriteLine("// methods");
                foreach (var method in t.Elements("method"))
                {
                    mcomparer.Added(method, true);
                }
            }

            t = target.Element("classes");
            if (t != null)
            {
                Output.WriteLine();
                Indent().WriteLine("// inner types");
                State.Parent = State.Type;
                kcomparer    = new NestedClassComparer();
                foreach (var inner in t.Elements("class"))
                {
                    kcomparer.AddedInner(inner);
                }
                State.Type = State.Parent;
            }
            State.Indent--;
            Indent().WriteLine("}");
        }
Example #2
0
		public void AddedInner (XElement target)
		{
			SetContext (target);
			if (target.IsTrue ("serializable"))
				Indent ().WriteLine ("[Serializable]");

			var type = target.Attribute ("type").Value;

			if (type == "enum") {
				// check if [Flags] is present
				var cattrs = target.Element ("attributes");
				if (cattrs != null) {
					foreach (var ca in cattrs.Elements ("attribute")) {
						if (ca.GetAttribute ("name") == "System.FlagsAttribute") {
							Indent ().WriteLine ("[Flags]");
							break;
						}
					}
				}
			}

			Indent ().Write ("public");

			if (type != "enum") {
				bool seal = target.IsTrue ("sealed");
				bool abst = target.IsTrue ("abstract");
				if (seal && abst)
					Output.Write (" static");
				else if (seal && type != "struct")
					Output.Write (" sealed");
				else if (abst && type != "interface")
					Output.Write (" abstract");
			}

			Output.Write (' ');
			Output.Write (type);
			Output.Write (' ');
			Output.Write (target.GetAttribute ("name"));

			var baseclass = target.GetAttribute ("base");
			if ((type != "enum") && (type != "struct")) {
				if (baseclass != null) {
					if (baseclass == "System.Object") {
						// while true we do not need to be reminded every time...
						baseclass = null;
					} else {
						Output.Write (" : ");
						Output.Write (baseclass);
					}
				}
			}

			// interfaces on enums are "standard" not user provided - so we do not want to show them
			if (type != "enum") {
				var i = target.Element ("interfaces");
				if (i != null) {
					var interfaces = new List<string> ();
					foreach (var iface in i.Elements ("interface"))
						interfaces.Add (icomparer.GetDescription (iface));
					Output.Write ((baseclass == null) ? " : " : ", ");
					Output.Write (String.Join (", ", interfaces));
				}
			}

			Output.WriteLine (" {");

			var t = target.Element ("constructors");
			if (t != null) {
				Indent ().WriteLine ("\t// constructors");
				foreach (var ctor in t.Elements ("constructor"))
					ccomparer.Added (ctor);
			}

			t = target.Element ("fields");
			if (t != null) {
				if (type != "enum")
					Indent ().WriteLine ("\t// fields");
				else
					SetContext (target);
				foreach (var field in t.Elements ("field"))
					fcomparer.Added (field);
			}

			t = target.Element ("properties");
			if (t != null) {
				Indent ().WriteLine ("\t// properties");
				foreach (var property in t.Elements ("property"))
					pcomparer.Added (property);
			}

			t = target.Element ("events");
			if (t != null) {
				Indent ().WriteLine ("\t// events");
				foreach (var evnt in t.Elements ("event"))
					ecomparer.Added (evnt);
			}

			t = target.Element ("methods");
			if (t != null) {
				Indent ().WriteLine ("\t// methods");
				foreach (var method in t.Elements ("method"))
					mcomparer.Added (method);
			}

			t = target.Element ("classes");
			if (t != null) {
				Output.WriteLine ();
				Indent ().WriteLine ("\t// inner types");
				kcomparer = new NestedClassComparer ();
				State.Indent++;
				foreach (var inner in t.Elements ("class"))
					kcomparer.AddedInner (inner);
				State.Indent--;
			}
			Indent ().WriteLine ("}");
		}