Inheritance: IDisposable
 // Methods
 internal virtual void WriteTo( XmlWriter xmlWriter )
 {
     xmlWriter.WriteStartElement( XmlDiff.Prefix, "descriptor", XmlDiff.NamespaceUri );
     xmlWriter.WriteAttributeString( "opid", _operationID.ToString() );
     xmlWriter.WriteAttributeString( "type", Type );
     xmlWriter.WriteEndElement();
 }
Example #2
1
        internal void WriteXml(XmlWriter writer)
        {
            writer.WriteAttributeString("classCode", ClassCode);

            its.TemplateSignpost(templateId + "#" + templateText, writer);
            writeXML(writer);

            if (assignedPerson != null)
            {
                writer.WriteStartElement("assignedPerson");
                assignedPerson.TemplateId = templateId;
                assignedPerson.TemplateText = "assignedPerson";
                assignedPerson.WriteXml(writer);
                writer.WriteEndElement();
            }

            if (assignedDevice != null)
            {
                writer.WriteStartElement("assignedAuthoringDevice");
                assignedDevice.TemplateId = templateId;
                assignedDevice.TemplateText = "assignedAuthoringDevice";
                assignedDevice.WriteXml(writer);
                writer.WriteEndElement();
            }

            if (representedOrganisation != null)
            {
                writer.WriteStartElement("representedOrganization");
                representedOrganisation.TemplateId = templateId;
                representedOrganisation.TemplateText = "representedOrganization";
                representedOrganisation.WriteXml(writer);
                writer.WriteEndElement();
            }
        }
        public override void SerializeNetwork(XmlWriter xmlWriter)
        {
            base.SerializeNetwork(xmlWriter);

            var expander = ControlElements[0] as SliderExpanderDouble;
            if (expander == null) return;

            xmlWriter.WriteStartAttribute("SliderMax");
            xmlWriter.WriteValue(expander.SliderMax);
            xmlWriter.WriteEndAttribute();

            xmlWriter.WriteStartAttribute("SliderMin");
            xmlWriter.WriteValue(expander.SliderMin);
            xmlWriter.WriteEndAttribute();

            xmlWriter.WriteStartAttribute("SliderValue");
            xmlWriter.WriteValue(expander.SliderValue);
            xmlWriter.WriteEndAttribute();

            xmlWriter.WriteStartAttribute("SliderStep");
            xmlWriter.WriteValue(expander.SliderStep);
            xmlWriter.WriteEndAttribute();

            xmlWriter.WriteStartAttribute("IsExpanded");
            xmlWriter.WriteValue(expander.IsExpanded);
            xmlWriter.WriteEndAttribute();
        }
    /// <summary>
    /// Applies the transformation from the reader to the writer
    /// </summary>
    /// <param name="reader"></param>
    /// <param name="writer"></param>
    public void Transform(XmlReader reader, XmlWriter writer) {
      Contract.Requires(reader != null);
      Contract.Requires(writer != null);

      while (reader.Read())
        this.WriteNodeSingle(reader, writer);
    }
Example #5
1
        void SanitizerNodeVisited(string nodeName, HtmlNode node, XmlWriter writer)
        {
            if (nodeName == "img" && node.Attributes["src"] != null && node.Attributes["src"].Value.StartsWith("cid:"))
            {
                // split src
                var src = node.Attributes["src"].Value.Split(new[] { ':' }, 2);

                if (src.Length == 2)
                {
                    // Find inline attachment with given contentid
                    var document = source.Documents.FirstOrDefault(d => d.ContentType == ContentType.Inline && d.ContentId == src[1]);

                    if (document != null)
                    {
                        // Replace content-id url with filename
                        var filename = ClientState.Current.Storage.ResolvePhysicalFilename(".", document.StreamName);

                        node.Attributes["src"].Value = String.Format("file://{0}", filename);
                    }
                }
            }
            else if (nodeName == "a" && node.Attributes["href"] != null)
            {
                var url = node.Attributes["href"].Value;

                // Clean href and inject javascript hook
                node.Attributes["href"].Value = String.Empty;

                writer.WriteAttributeString("onclick", String.Format("javascript:window.external.JsNavigate('{0}')", url));
            }
        }
        /// <summary>
        /// Writes all experiment graph attributes.
        /// </summary>
        /// <param name="writer">The writer.</param>
        /// <param name="flow">The flow.</param>
        public virtual void WriteGraphAttributes(XmlWriter writer, IExperiment flow)
        {
            string path = System.IO.Path.Combine(System.IO.Path.GetTempPath(), Guid.NewGuid().ToString());
            System.IO.Directory.CreateDirectory(path);

            PropertyDescriptorCollection propertiesToWrite = TypeDescriptor.GetProperties(flow);
            foreach (PropertyDescriptor property in propertiesToWrite)
            {
                WriteXmlAttribute(writer, property, flow);
            }

            writer.WriteStartElement("References");
            {
                if (flow.References != null)
                {
                    var serializer = TraceLab.Core.Serialization.XmlSerializerFactory.GetSerializer(typeof(PackageSystem.PackageReference), null);
                    foreach (IPackageReference reference in flow.References)
                    {
                        serializer.Serialize(writer, reference);
                    }
                }
            }
            writer.WriteEndElement();

            // Iterate again and write any elements that are pending.  ALL attributes must be done first, or it results in invalid XML
            foreach (PropertyDescriptor property in propertiesToWrite)
            {
                WriteXmlElement(writer, property, flow);
            }
        }
Example #7
1
        protected internal override void WriteXmlAttributes(XmlWriter writer)
        {
            if (Mode == VerticesEnumeratorMode.Range)
            {
                writer.WriteStartAttribute(StartField);
                writer.WriteValue(Start);
                writer.WriteEndAttribute();

                writer.WriteStartAttribute(EndField);
                writer.WriteValue(End);
                writer.WriteEndAttribute();

                writer.WriteStartAttribute(IncField);
                writer.WriteValue(Increment);
                writer.WriteEndAttribute();
            }
            
            if (Mode != VerticesEnumeratorMode.All)
            {
                writer.WriteStartAttribute(ModeField);
                writer.WriteValue(Mode.ToString());
                writer.WriteEndAttribute();
            }

            base.WriteXmlAttributes(writer);
        }
 public static void writeVertex(XmlWriter writer, Vector2D vert)
 {
     writer.WriteStartElement("vertex");
     writer.WriteAttributeString("x", vert.x.ToString());
     writer.WriteAttributeString("y", vert.y.ToString());
     writer.WriteEndElement();
 }
Example #9
1
 private static void WriteAlbum(XmlWriter writer, string albumTitle, string artist)
 {
     writer.WriteStartElement("album");
     writer.WriteElementString("title", albumTitle);
     writer.WriteElementString("artist", artist);
     writer.WriteEndElement();
 }
        public override void Validate(XmlWriter output, SchematronRuntimeOptions options)
        {
            if (output == null) throw new ArgumentNullException("output");
             if (options == null) throw new ArgumentNullException("options");

             this.executable.Run(output, GetXsltOptions(options));
        }
Example #11
1
		internal WrappedSerializer(Serialization.DataFormat dataFormat, string streamName, TextWriter output) : base(dataFormat, streamName)
		{
			this.firstCall = true;
			this.textWriter = output;
			Serialization.DataFormat dataFormat1 = this.format;
			switch (dataFormat1)
			{
				case Serialization.DataFormat.Text:
				{
					return;
				}
				case Serialization.DataFormat.XML:
				{
					XmlWriterSettings xmlWriterSetting = new XmlWriterSettings();
					xmlWriterSetting.CheckCharacters = false;
					xmlWriterSetting.OmitXmlDeclaration = true;
					this.xmlWriter = XmlWriter.Create(this.textWriter, xmlWriterSetting);
					this.xmlSerializer = new Serializer(this.xmlWriter);
					return;
				}
				default:
				{
					return;
				}
			}
		}
        protected virtual void WriteItem(XmlWriter writer, string baseUrl, SiteMapEntry item)
        {
            // <url>
            if (item.Url.StartsWith("http")) return;
            
            writer.WriteStartElement("url");
#if DEBUG2           
            if (!string.IsNullOrEmpty(item.ID))
                writer.WriteElementString("id", item.ID);

            if (!string.IsNullOrEmpty(item.Title))
                writer.WriteElementString("title", item.Title);

            if (!string.IsNullOrEmpty(item.Class))
                writer.WriteElementString("class", item.Class);
#endif   
            writer.WriteElementString("loc", baseUrl + item.Url);
            
            if (item.LastModified.HasValue)
                 writer.WriteElementString("lastmod", item.LastModified.Value.ToString("yyyy-MM-dd")); // Google doesn't like IS0 8601/W3C 
            
            if (item.ChangeFrequency != ChangeFrequencyEnum.Undefined)
                writer.WriteElementString("changefreq", item.ChangeFrequency.ToString().ToLowerInvariant());
            
            writer.WriteElementString("priority", item.Priority.ToString(CultureInfo.InvariantCulture)); 

            // </url>
            writer.WriteEndElement();
        }
 public override void WritePaymentSpecificXml(XmlWriter xmlw)
 {
     if (_paymentMethod != null)
     {
         WriteSimpleElement(xmlw, "paymentmethod", _paymentMethod.Value);
     }
 }
 void IXmlSerializable.WriteXml(XmlWriter writer)
 {
     if (address != null)
     {
         address.WriteContentsTo(this.addressVersion, writer);
     }
 }
 public override void PrintQuery(XmlWriter w) {
     w.WriteStartElement(this.GetType().Name);
     w.WriteAttributeString("op", (isOr ? Operator.Op.OR : Operator.Op.AND).ToString());
     opnd1.PrintQuery(w);
     opnd2.PrintQuery(w);
     w.WriteEndElement();
 }
        private static void WriteCLPSToXML(XmlWriter writer)
        {
            writer.WriteStartElement("CLPS");

            uint clps_addr = m_Overlay.ReadPointer(0x60);
            uint clps_num = m_Overlay.Read16(clps_addr + 0x06);
            uint clps_size = (uint)(8 + (clps_num * 8));
            byte[][] entries = new byte[clps_num][];
            uint entry = clps_addr + 0x08;

            for (int i = 0; i < clps_num; i++)
            {
                entries[i] = new byte[8];

                for (int j = 0; j < 8; j++)
                    entries[i][j] = m_Overlay.Read8((uint)(entry + (j)));

                entry += 8;
            }

            for (int i = 0; i < entries.Length; i++)
            {
                writer.WriteStartElement("Entry");
                writer.WriteStartElement("Value");
                for (int j = 0; j < entries[i].Length; j++)
                    writer.WriteElementString("Byte", entries[i][j].ToString());

                writer.WriteEndElement();
                writer.WriteEndElement();
            }

            writer.WriteEndElement();
        }
		void WritePatchedImport (XmlWriter writer, string newTarget)
		{
			/* If an import redirect exists, add a fake import to the project which will be used only
			   if the original import doesn't exist. That is, the following import:

			   <Import Project = "PathToReplace" />

			   will be converted into:

			   <Import Project = "PathToReplace" Condition = "Exists('PathToReplace')"/>
			   <Import Project = "ReplacementPath" Condition = "!Exists('PathToReplace')" />
			*/

			// Modify the original import by adding a condition, so that this import will be used only
			// if the targets file exists.

			string cond = "Exists('" + target + "')";
			if (!string.IsNullOrEmpty (Condition))
				cond = "( " + Condition + " ) AND " + cond;
			
			writer.WriteStartElement ("Import", MSBuildProject.Schema);
			writer.WriteAttributeString ("Project", target);
			writer.WriteAttributeString ("Condition", cond);

			// Now add the fake import, with a condition so that it will be used only if the original
			// import does not exist.

			cond = "!Exists('" + target + "')";
			if (!string.IsNullOrEmpty (Condition))
				cond = "( " + Condition + " ) AND " + cond;

			writer.WriteStartElement ("Import", MSBuildProject.Schema);
			writer.WriteAttributeString ("Project", MSBuildProjectService.ToMSBuildPath (null, newTarget));
			writer.WriteAttributeString ("Condition", cond);
		}
            internal override void WriteTo(XmlWriter xml)
            {
                if (xml == null)
                    return;

                xml.WriteComment(SR.GetString(SR.ServiceNameFromClient));
                xml.WriteElementString("ServiceName", this.serviceBindingNameSentByClient);

                xml.WriteComment(SR.GetString(SR.ServiceNameOnService));
                xml.WriteStartElement("ServiceNameCollection");
                if (this.serviceNameCollectionConfiguredOnServer == null || this.serviceNameCollectionConfiguredOnServer.Count < 1)
                {
                    xml.WriteElementString("ServiceName", this.defaultServiceBindingNameOfServer);
                }
                else
                {
                    foreach (string serviceName in this.serviceNameCollectionConfiguredOnServer)
                    {
                        xml.WriteElementString("ServiceName", serviceName);
                    }
                }

                xml.WriteFullEndElement();

            }
Example #19
0
        /// <summary>
        /// Initializes a new instance of the <see cref="XmlExceptionFormatter"/> class using the specified <see cref="XmlWriter"/> and <see cref="Exception"/> objects.
        /// </summary>
        /// <param name="xmlWriter">The <see cref="XmlWriter"/> in which to write the XML.</param>
        /// <param name="exception">The <see cref="Exception"/> to format.</param>
        public XmlExceptionFormatter(XmlWriter xmlWriter, Exception exception)
            : base(exception)
        {
            if (xmlWriter == null) throw new ArgumentNullException("xmlWriter");

            this.xmlWriter = xmlWriter;
        }
Example #20
0
 public override void WriteXml(XmlWriter writer)
 {
     writer.WriteElementString("Format", Format);
     writer.WriteStartElement("OnlineResource", Namespace);
     OnlineResource.WriteXml(writer);
     writer.WriteEndElement();
 }
Example #21
0
		public void Save(object obj, XmlWriter writer)
		{
			Type t = obj.GetType();
		
//			writer.WriteStartElement(GetTypeName(t));
//			System.Console.WriteLine("\tSave <{0}>",GetTypeName(t));
			                        
			writer.WriteStartElement(obj.GetType().Name);
			
			PropertyDescriptorCollection properties = TypeDescriptor.GetProperties(obj);
			PropertyInfo [] propertyInfos = new PropertyInfo[properties.Count];
			
			for (int i = 0;i < properties.Count ; i ++){
				propertyInfos[i] = t.GetProperty(properties[i].Name);
			}
			
			foreach (PropertyInfo info in propertyInfos) {
				if (info ==  null){
					continue;
				}
				if (!info.CanRead) continue;
				
				if (info.GetCustomAttributes(typeof(XmlIgnoreAttribute), true).Length != 0) continue;
				object val = info.GetValue(obj, null);
				if (val == null) continue;
				if (val is ICollection) {
//					PropertyInfo pinfo = t.GetProperty(info.Name);
//					Console.WriteLine("pinfo {0}",pinfo.Name);
					if (info.Name.StartsWith("Contr")) {
						writer.WriteStartElement("Items");
					} else {
					writer.WriteStartElement(info.Name);
					}
					foreach (object element in (ICollection)val) {
						Save(element, writer);
					}
					
					writer.WriteEndElement();
				} else {
					if (!info.CanWrite) continue;
				
					TypeConverter c = TypeDescriptor.GetConverter(info.PropertyType);
					if (c.CanConvertFrom(typeof(string)) && c.CanConvertTo(typeof(string))) {
						try {
							writer.WriteElementString(info.Name, c.ConvertToInvariantString(val));
						} catch (Exception ex) {
							writer.WriteComment(ex.ToString());
						}
					} else if (info.PropertyType == typeof(Type)) {
						writer.WriteElementString(info.Name, ((Type)val).AssemblyQualifiedName);
					} else {
//						System.Diagnostics.Trace.WriteLine("Serialize Pagelayout");
//						writer.WriteStartElement(info.Name);
//						Save(val, writer);
//						writer.WriteEndElement();
					}
				}
			}
			writer.WriteEndElement();
		}
 internal override void WriteTo(XmlWriter xml)
 {
     TraceHelper.WriteTraceSource(xml, this.traceSource);
     TraceHelper.WriteEnId(xml, this.enTraceId);
     xml.WriteElementString("EnlistmentType", this.enType.ToString());
     xml.WriteElementString("EnlistmentOptions", this.enOptions.ToString());
 }
        /// <summary>
        /// Generates  output data in html form
        /// </summary>
        /// <param name="writer">output stream</param>
        /// <param name="indent">number of indentations</param>
        internal override void DrawHtml(XmlWriter writer, int indent)
        {
            if (Operation == XmlDiffViewOperation.Change)
            {
                Debug.Assert(this.declarationValue != ChangeInformation.Subset);

                XmlDiffView.HtmlStartRow(writer);
                this.DrawLinkNode(writer);
                XmlDiffView.HtmlStartCell(writer, indent);
                XmlDiffView.HtmlWriteString(writer, Tags.XmlDeclarationBegin);
                XmlDiffView.HtmlWriteString(writer, XmlDiffViewOperation.Change, this.declarationValue);
                XmlDiffView.HtmlWriteString(writer, Tags.XmlDeclarationEnd);

                XmlDiffView.HtmlEndCell(writer);
                XmlDiffView.HtmlStartCell(writer, indent);

                XmlDiffView.HtmlWriteString(writer, Tags.XmlDeclarationBegin);
                XmlDiffView.HtmlWriteString(writer, XmlDiffViewOperation.Change, ChangeInformation.Subset);
                XmlDiffView.HtmlWriteString(writer, Tags.XmlDeclarationEnd);

                XmlDiffView.HtmlEndCell(writer);
                XmlDiffView.HtmlEndRow(writer);
            }
            else
            {
                DrawHtmlNoChange(writer, indent);
            }
        }
 public override void Write(XmlWriter writer)
 {
     writer.WriteStartElement("sequence", NAMESPACE);
     foreach (var particles in Particles)
         particles.Write(writer);
     writer.WriteEndElement();
 }
        protected override void WriteTokenCore( XmlWriter writer, System.IdentityModel.Tokens.SecurityToken token )
        {
            if ( writer == null )
                throw new ArgumentNullException( "writer" );

            if ( token == null )
                throw new ArgumentNullException( "token" );

            var c = token as SecurityToken;
            if ( c != null )
            {
                writer.WriteStartElement( Constants.UsernameTokenPrefix, Constants.UsernameTokenName, Constants.UsernameTokenNamespace );
                writer.WriteAttributeString( Constants.WsUtilityPrefix, Constants.IdAttributeName, Constants.WsUtilityNamespace, token.Id );
                writer.WriteElementString( Constants.UsernameElementName, Constants.UsernameTokenNamespace, c.Info.Username );
                writer.WriteStartElement( Constants.UsernameTokenPrefix, Constants.PasswordElementName, Constants.UsernameTokenNamespace );
                writer.WriteAttributeString( Constants.TypeAttributeName, Constants.PasswordDigestType );
                writer.WriteValue( c.GetPasswordDigestAsBase64() );
                writer.WriteEndElement();
                writer.WriteElementString( Constants.NonceElementName, Constants.UsernameTokenNamespace, c.GetNonceAsBase64() );
                writer.WriteElementString( Constants.CreatedElementName, Constants.WsUtilityNamespace, c.GetCreatedAsString() );
                writer.WriteEndElement();
                writer.Flush();
            }
            else
                base.WriteTokenCore( writer, token );
        }
        private static void WriteReportFieldsXml(XmlWriter writer, Report report)
        {
            writer.WriteStartElement("Fields");

            foreach (var field in report.Fields.Where(field => field.FieldType != FieldType.SectionRepeater))
            {
                writer.WriteStartElement("Field-" + field.FieldType);
                writer.WriteAttributeString("Label", field.Label);

                if (field.FieldType != FieldType.CheckList && field.FieldType != FieldType.Location)
                {
                    writer.WriteString(field.Value);
                }
                else
                {
                    foreach (var item in field.ChildItems)
                    {
                        writer.WriteElementString(item.Item, item.Value);
                    }
                }

                writer.WriteEndElement();
            }

            writer.WriteEndElement();
        }
        public static void WriteXml(XmlWriter writer, string key, Property value)
        {
            writer.WriteStartElement("PropertyEntry");

            writer.WriteAttributeString("Key", key);

            var type = value.GetType();
            try
            {
                var ser = GetSerializer(type);
                writer.WriteAttributeString("Type", type.AssemblyQualifiedName);
                ser.Serialize(writer, value);
            }
            catch (Exception ex)
            {
                Console.WriteLine("Serialization failed: " + ex.Message);
                Console.WriteLine("Property Key: " + key);
                Console.WriteLine("Property Value: " + value);
                Console.WriteLine("Property Type Name: " + type.Name);
                Console.WriteLine("Property Type Qualified Name: " + type.AssemblyQualifiedName);
                Console.WriteLine("Stacktrace: " + ex.StackTrace);
            }

            writer.WriteEndElement();
        }
 public override void WriteTo(XmlWriter w)
 {
     if (this.fSpecified)
     {
         base.WriteTo(w);
     }
 }
Example #29
0
		public override void ToXml(XmlWriter xwriter)
		{
			xwriter.WriteStartElement("IirFilter");
			xwriter.WriteElementString("CoefA", Util.ArrayToString(this.CoefA));
			xwriter.WriteElementString("CoefB", Util.ArrayToString(this.CoefB));
			xwriter.WriteEndElement();
		}
        public void Serialize(DbDatabaseMapping databaseMapping, DbProviderInfo providerInfo, XmlWriter xmlWriter)
        {
            //Contract.Requires(xmlWriter != null);
            //Contract.Requires(databaseMapping != null);
            //Contract.Requires(providerInfo != null);
            Contract.Assert(databaseMapping.Model != null);
            Contract.Assert(databaseMapping.Database != null);

            _xmlWriter = xmlWriter;
            _databaseMapping = databaseMapping;
            _version = databaseMapping.Model.Version;
            _providerInfo = providerInfo;
            _namespace = _version == DataModelVersions.Version3 ? EdmXmlNamespaceV3 : EdmXmlNamespaceV2;

            _xmlWriter.WriteStartDocument();

            using (Element("Edmx", "Version", string.Format(CultureInfo.InvariantCulture, "{0:F1}", _version)))
            {
                WriteEdmxRuntime();
                WriteEdmxDesigner();
            }

            _xmlWriter.WriteEndDocument();
            _xmlWriter.Flush();
        }