static internal PipeLaunchOptions CreateFromXml(Xml.LaunchOptions.PipeLaunchOptions source)
        {
            var options = new PipeLaunchOptions(RequireAttribute(source.PipePath, "PipePath"), source.PipeArguments);
            options.InitializeCommonOptions(source);

            return options;
        }

 public Util(Core RennderCore)
 {
     R = RennderCore;
     Str = new Str(R);
     Xml = new Xml();
     Serializer = new Serializer(R);
 }

        public static byte[] Build(Xml.FileGroupXml group, string spriteFile)
        {
            var bmps = group.Files.Select(x => new System.Drawing.Bitmap(x.Path));

            var maxWidth = bmps.Max(x => x.Width);
            var totalHeight = bmps.Sum(x => x.Height);

            int top = 0;
            using (var sprite = new System.Drawing.Bitmap(maxWidth, totalHeight))
            using (var mem = new System.IO.MemoryStream())
            using (var g = System.Drawing.Graphics.FromImage(sprite))
            {
                foreach (var bmp in bmps)
                {
                    using (bmp)
                    {
                        g.DrawImage(bmp, new System.Drawing.Rectangle(0, top, bmp.Width, bmp.Height), new System.Drawing.Rectangle(0, 0, bmp.Width, bmp.Height), System.Drawing.GraphicsUnit.Pixel);
                        top += bmp.Height;
                    }
                }

                sprite.Save(mem, GetFormat(spriteFile) ?? System.Drawing.Imaging.ImageFormat.Png);
                return mem.ToArray();
            }
        }

            public static Xml createMessage(string type)
            {
                Xml ret = new Xml("msg");
                ret.root.attribute("type").set(type);

                return ret;
            }

 public IEnumerable<Xml.IQueryableNode> FollowingSiblings(Xml.IQueryableNode node)
 {
   var result = node.FollowingSibling();
   while (result != null)
   {
     yield return result;
     result = result.FollowingSibling();
   }
 }

        public NuGetDependency(Xml.NuGet.NuSpec.Dependency dependency)
            : this()
        {
            Dependency = dependency;

            _uiName.Text = Dependency.Id;
            _uiVersion.Text = Dependency.Version;
            _uiOriginalFramework.Text = Dependency.OriginalTargetFramework;
        }

        public static ReadOnlyCollection<LaunchCommand> CreateCollectionFromXml(Xml.LaunchOptions.Command[] source)
        {
            LaunchCommand[] commandArray = source?.Select(x => new LaunchCommand(x.Value, x.Description, x.IgnoreFailures)).ToArray();
            if (commandArray == null)
            {
                commandArray = new LaunchCommand[0];
            }

            return new ReadOnlyCollection<LaunchCommand>(commandArray);
        }

 public void Xml_CData_AddsCDataNode()
 {
     var xml = new Xml();
     xml.Tag("tag", Xml.Fragment(() =>
     {
         xml.CData("content");
         xml.Tag("hello", "world");
     }));
     Assert.Equal("<tag><![CDATA[content]]><hello>world</hello></tag>", xml);
 }

 internal void WriteSvg(Xml.SvgWriter w)
 {
     w.WriteStartElement("pressure");
     w.WriteAttributeString("midiChannel", _midiChannel.ToString());
     if(_inputControls != null)
     {
         _inputControls.WriteSvg(w);
     }
     w.WriteEndElement(); // trkOff
 }

	public Xml()
	{
		if (instance != null)
		{
			return;
		}
		else
		{
			instance = this;
		}
	}

        public void Initialize(Xml.XAccessor x)
        {
            string strHostType = x.GetStringValue(CLASS);
            if (string.IsNullOrEmpty(strHostType))
                ExceptionHelper.ThrowPolicyInitNullError(this.GetType(), CLASS);
            Type hostType = Reflector.LoadType(strHostType);
            string memberName = x.GetStringValue(MEMBER);
            if (string.IsNullOrEmpty(memberName))
                ExceptionHelper.ThrowPolicyInitNullError(this.GetType(), MEMBER);

            IReflector r = Reflector.Bind(hostType, ReflectorPolicy.TypePublic);
            _instance = r.GetPropertyOrFieldValue(memberName, false);
        }

 /// <summary>
 /// This function only writes TrkRefs that refer to Trks stored in external VoiceDefs. 
 /// Note that successive Trks in the same VoiceDef may, in principle, contain common IUniqueDefs...
 /// SVG files contain voice definitions that contain MidiChordDefs and restDefs, but no Trks.
 /// </summary>
 /// <param name="w"></param>
 internal void WriteSvg(Xml.SvgWriter w)
 {
     w.WriteStartElement("seq");
     if(TrkOptions != null)
     {
         TrkOptions.WriteSvg(w, false);
     }
     Debug.Assert(TrkRefs != null && TrkRefs.Count > 0);
     foreach(TrkRef trkRef in TrkRefs)
     {
         trkRef.WriteSvg(w);
     }
     w.WriteEndElement(); // seq
 }

 internal void WriteSvg(Xml.SvgWriter w)
 {
     w.WriteStartElement("pressures");
     if(_inputControls != null)
     {
         _inputControls.WriteSvg(w);
     }
     Debug.Assert(_pressures != null && _pressures.Count > 0);
     foreach(Pressure pressure in _pressures)
     {
         pressure.WriteSvg(w);
     }
     w.WriteEndElement(); // pressures
 }

 internal void WriteSvg(Xml.SvgWriter w)
 {
     w.WriteStartElement("trkOffs");
     if(_inputControls != null)
     {
         _inputControls.WriteSvg(w);
     }
     Debug.Assert(_trkOffs != null && _trkOffs.Count > 0);
     foreach(TrkOff trkOff in _trkOffs)
     {
         trkOff.WriteSvg(w);
     }
     w.WriteEndElement(); // trkOffs
 }

        /// <inheritdoc />
        public IEnumerable<IAnalysisLogDiff> DiffReturnValues(Xml.Value oldValue, Xml.Value newValue)
        {
            // If both values are not null...
            IEnumerable<IAnalysisLogDiff> list;
            if (oldValue != null && newValue != null)
            {
                if (!newValue.IsComparableTo(oldValue))
                {
                    var msg = string.Format(
                        "Items are incompatible for comparison! oldObject.Item.Type => {0}, newObject.Item.Type => {1}",
                        oldValue.UnderlyingType,
                        newValue.UnderlyingType);
                    throw new ArgumentException(msg);
                }

                if (newValue.IsPrimtive && oldValue.IsPrimtive && !newValue.AsPrimitive.Equals(oldValue.AsPrimitive))
                {
                    list = new IAnalysisLogDiff[]
                    {
                        new ReturnValueAnalysisLogDiff(oldValue.AsPrimitive.Value, newValue.AsPrimitive.Value, newValue.AsPrimitive.FullName)
                    };
                }
                else if (newValue.IsObject && oldValue.IsObject)
                {
                    list = this.DiffObjects(oldValue.AsObject, newValue.AsObject);
                }
                else
                {
                    // No diff.
                    list = Enumerable.Empty<IAnalysisLogDiff>();
                }
            }
            else if (oldValue == null && newValue == null)
            {
                // No diff.
                list = Enumerable.Empty<IAnalysisLogDiff>();
            }
            else
            {
                // Either the old or new value is null. Not sure what happened here--should be impossible.
                var msg = string.Format(
                    "The {0} return value was null! This indicates an analysis log file corruption. Terminating analysis!",
                    oldValue == null ? "old" : "current");
                throw new ArgumentException(msg);
            }

            return list;
        }

        protected ElementBase(Xml.ElementGroup node)
        {
            if (node.name.StartsWith("&#x"))
            {
                string[] val = node.name.Split(new[] {';'}, 2, StringSplitOptions.None);
                var c = (char) int.Parse(val[0].Substring(3), NumberStyles.HexNumber, null);
                this.name = c + val[1];
            }
            else
            {
                this.name = node.name;
            }

            this.repeat = node.repeat;
            this.optional = node.optional;
            this.desc = node.desc;
        }

    public IEnumerable<Xml.IQueryableNode> Parents(Xml.IQueryableNode node)
    {
      var curr = node;
      var result = node.Parent();
      while (result != null)
      {
        if (string.Compare(curr.Name.LocalName, "tr", StringComparison.OrdinalIgnoreCase) == 0 &&
          string.Compare(result.Name.LocalName, "table", StringComparison.OrdinalIgnoreCase) == 0)
        {
          yield return new TbodyNode(curr);
        }

        yield return result;
        curr = result;
        result = result.Parent();
      }

      var html = new HtmlNode();
      switch (curr.Name.LocalName.ToLowerInvariant())
      {
        case "html":
          // do nothing
          break;
        case "body":
        case "head":
          yield return html;
          break;
        case "title":
        case "base":
        case "link":
        case "style":
        case "meta":
        case "script":
        case "noscript":
        case "command":
          yield return new HeadNode(curr, null, html);
          yield return html;
          break;
        default:
          yield return new BodyNode(curr, null, html);
          yield return html;
          break;
      }
    }

        public NuGetDependencyGroup(Xml.NuGet.NuSpec.Group dependencyGroup)
            : this()
        {
            Group = dependencyGroup;

            _uiTargetFramework.Text = Group.TargetFramework;

            foreach (Xml.NuGet.NuSpec.Dependency dependency in dependencyGroup.Dependencies)
            {
                _uiDependencies.Items.Add(new NuGetDependency(dependency)
                {
                    OnRemoveFromDependencyGroup = OnDependencyRemovedFromGroup
                });
            }

            _uiItemsCount.Text = _uiDependencies.Items.Count.ToString();

            Refresh();
        }

 protected override bool HandleElement(Xml.XmlReader reader)
 {
     if (base.HandleElement(reader))
     {
         return true;
     } 
     else if (CanHandleElement(reader, XmlConstants.ValueAnnotation))
     {
         // EF does not support this EDM 3.0 element, so ignore it.
         SkipElement(reader);
         return true;
     }
     else if (CanHandleElement(reader, XmlConstants.TypeAnnotation))
     {
         // EF does not support this EDM 3.0 element, so ignore it.
         SkipElement(reader);
         return true;
     }
     return false;
 }

        public SubrecordStructure(Xml.Subrecord node)
            : base(node)
        {
            this.notininfo = node.notininfo;
            this.size = node.size;
            this.Condition = (!string.IsNullOrEmpty(node.condition))
                                 ? (CondType) Enum.Parse(typeof (CondType), node.condition, true)
                                 : CondType.None;
            this.CondID = node.condid;
            this.CondOperand = node.condvalue;
            this.UseHexEditor = node.usehexeditor;

            // if (optional && repeat)
            // {
            // throw new RecordXmlException("repeat and optional must both have the same value if they are non zero");
            // }

            this.elementTree = GetElementTree(node.Items).ToArray();
            this.elements = GetElementArray(elementTree).ToArray();
            this.ContainsConditionals = this.elements.Count(x => x.CondID != 0) > 0;
        }