WriteString() public abstract method

public abstract WriteString ( string text ) : void
text string
return void
Example #1
0
        /// <summary>
        /// Creates XML elements from the data of the system.
        /// </summary>
        /// <param name="xmlWriter">Object with the XML message to add new information and return to client side</param>
        /// <param name="val">Value to be puted inside the XML message</param>
        /// <param name="dtdVersion">Version of the DTD that follows the XML message</param>
        /// <param name="xmlElement">Element of the XML that is checked</param>
        public static void ON2XML(XmlWriter xmlWriter, ONBool val, double dtdVersion, string xmlElement)
        {
            if (val == null)
            {
                if (xmlElement == ONXml.XMLTAG_V)
                    xmlWriter.WriteElementString(xmlElement, "");
                else
                    xmlWriter.WriteElementString(ONXml.XMLTAG_NULL, null);
            }
            else
            {
                if (dtdVersion < 2.0) // Apply the locale format
                {
                    if (val.TypedValue)
                        xmlWriter.WriteElementString(xmlElement, "Verdadero");
                    else
                        xmlWriter.WriteElementString(xmlElement, "Falso");
                }
                else
                {
                    xmlWriter.WriteStartElement(xmlElement);
                    if (xmlElement == ONXml.XMLTAG_OIDFIELD && dtdVersion > 2.0)
                        xmlWriter.WriteAttributeString("Type", "bool");

                    if (val.TypedValue)
                        xmlWriter.WriteString("true");
                    else
                        xmlWriter.WriteString("false");

                    xmlWriter.WriteEndElement();
                }
            }
        }
Example #2
0
        /// <summary>
        /// Creates XML elements from the data of the system.
        /// </summary>
        /// <param name="xmlWriter">Object with the XML message to add new information and return to client side</param>
        /// <param name="val">Value to be puted inside the XML message</param>
        /// <param name="dtdVersion">Version of the DTD that follows the XML message</param>
        /// <param name="xmlElement">Element of the XML that is checked</param>
        public static void ON2XML(XmlWriter xmlWriter, ONDateTime val, double dtdVersion, string xmlElement)
        {
            if (val == null)
            {
                if (xmlElement == ONXml.XMLTAG_V)
                    xmlWriter.WriteElementString(xmlElement, "");
                else
                    xmlWriter.WriteElementString(ONXml.XMLTAG_NULL, null);
            }
            else
            {
                if (dtdVersion < 2.0) // Apply the locale format
                    xmlWriter.WriteElementString(xmlElement, val.TypedValue.ToString());
                else
                {
                    xmlWriter.WriteStartElement(xmlElement);
                    if (xmlElement == ONXml.XMLTAG_OIDFIELD && dtdVersion > 2.0)
                        xmlWriter.WriteAttributeString("Type", "datetime");

                    if (val.TypedValue.Millisecond == 0)
                        xmlWriter.WriteString(val.TypedValue.ToString("yyyy-MM-ddTHH:mm:ss"));
                    else
                        xmlWriter.WriteString(val.TypedValue.ToString("yyyy-MM-ddTHH:mm:ss.fff"));
                    xmlWriter.WriteEndElement();
                }
            }
        }
Example #3
0
 private static void WriteXmlInnerError(XmlWriter writer, ODataInnerError innerError, string innerErrorElementName, int recursionDepth, int maxInnerErrorDepth)
 {
     recursionDepth++;
     if (recursionDepth > maxInnerErrorDepth)
     {
         throw new ODataException(Strings.ValidationUtils_RecursionDepthLimitReached(maxInnerErrorDepth));
     }
     writer.WriteStartElement("m", innerErrorElementName, "http://schemas.microsoft.com/ado/2007/08/dataservices/metadata");
     string text = innerError.Message ?? string.Empty;
     writer.WriteStartElement("message", "http://schemas.microsoft.com/ado/2007/08/dataservices/metadata");
     writer.WriteString(text);
     writer.WriteEndElement();
     string str2 = innerError.TypeName ?? string.Empty;
     writer.WriteStartElement("type", "http://schemas.microsoft.com/ado/2007/08/dataservices/metadata");
     writer.WriteString(str2);
     writer.WriteEndElement();
     string str3 = innerError.StackTrace ?? string.Empty;
     writer.WriteStartElement("stacktrace", "http://schemas.microsoft.com/ado/2007/08/dataservices/metadata");
     writer.WriteString(str3);
     writer.WriteEndElement();
     if (innerError.InnerError != null)
     {
         WriteXmlInnerError(writer, innerError.InnerError, "internalexception", recursionDepth, maxInnerErrorDepth);
     }
     writer.WriteEndElement();
 }
Example #4
0
        /// <summary>
        /// If the XmlDebugging property is set to true, writes a BytesRead
        /// node to the DebugXmlWriter containing a hexadecimal representation
        /// of the supplied byte array.
        /// If the XmlDebugging property is set to false, does nothing.
        /// </summary>
        /// <param name="elementName">The name of the element to write</param>
        /// <param name="bytes">The byte array to write</param>
        /// <exception cref="ArgumentNullException">
        /// The supplied byte array is null.
        /// </exception>
        protected void WriteDebugXmlByteValues(string elementName, int[] bytes)
        {
            if (bytes == null)
            {
                throw new ArgumentNullException("bytes");
            }

            if (_xmlDebugging)
            {
                _debugXmlWriter.WriteStartElement(elementName);
                StringBuilder sb = new StringBuilder();
                for (int i = 0; i < bytes.Length; i++)
                {
                    sb.Append(ToHex(bytes[i]) + " ");
                    int result;
                    Math.DivRem(i + 1, 16, out result);
                    if (result == 0)
                    {
                        _debugXmlWriter.WriteStartElement("ByteGroup");
                        _debugXmlWriter.WriteString(sb.ToString());
                        _debugXmlWriter.WriteEndElement();
                        sb = new StringBuilder();
                    }
                }

                _debugXmlWriter.WriteStartElement("ByteGroup");
                _debugXmlWriter.WriteString(sb.ToString());
                _debugXmlWriter.WriteEndElement();
                _debugXmlWriter.WriteEndElement();
            }
        }
Example #5
0
        /// <summary>
        /// Converts the object to its xml representation.
        /// </summary>
        /// <param name="writer">The <see cref="T:System.Xml.XmlWriter" />-stream, to which the object is serialized.</param>
        public void WriteXml(System.Xml.XmlWriter writer)
        {
            CurveTypeEnum?CT = GetCurveTypeEnum();

            //writer.WriteStartElement(GetType().ToString());
            writer.WriteStartElement("Name");
            writer.WriteString(Name);
            writer.WriteEndElement();

            writer.WriteStartElement("Curve");
            if (CT.HasValue)
            {
                writer.WriteString(CT.ToString());
            }
            else
            {
                StringBuilder S = new StringBuilder();
                for (int i = 0; i < 256; i++)
                {
                    S.AppendFormat("{0}, ", Data[i]);
                }
                writer.WriteString(S.ToString().Substring(0, S.Length - 2));
            }
            writer.WriteEndElement();
            // writer.WriteEndElement();
        }
Example #6
0
		internal override void WriteXml(XmlWriter writer)
		{
			if (base.IsSlot)
			{
                writer.WriteStartElement("Property", NodeQuery.XmlNamespace);
				writer.WriteAttributeString("name", base.PropertySlot.Name);
				writer.WriteEndElement();
			}
			else if (!IsValue)
			{
                writer.WriteStartElement("Property", NodeQuery.XmlNamespace);
				writer.WriteAttributeString("name", base.NodeAttribute.ToString());
				writer.WriteEndElement();
			}
			else
			{
				if (_value == null)
                    writer.WriteElementString("NullValue", NodeQuery.XmlNamespace, null);
				else if (_value is string)
					writer.WriteString((string)_value);
				else if (_value is int)
					writer.WriteString(XmlConvert.ToString((int)_value));
				else if (_value is decimal)
					writer.WriteString(XmlConvert.ToString((decimal)_value));
				if (_value is DateTime)
					writer.WriteString(XmlConvert.ToString((DateTime)_value, XmlDateTimeSerializationMode.Unspecified));
			}

		}
Example #7
0
 public void Render(System.Xml.XmlWriter writer)
 {
     writer.WriteStartElement("", "Customer", "mvp-xml-templates");
     writer.WriteAttributeString("", "xmlns", "http://www.w3.org/2000/xmlns/", "mvp-xml-templates");
     writer.WriteAttributeString("", "FullName", "", Converter.ToString(Customer.LastName + ", " + Customer.FirstName));
     foreach (Order o in this.Customer.Orders)    //;
     {
         writer.WriteStartElement("", "Order", "mvp-xml-templates");
         writer.WriteAttributeString("", "Id", "", Converter.ToString(o.Id));
         writer.WriteAttributeString("", "Premium", "", Converter.ToString(CalculateTotal(o) > 5000));
         writer.WriteAttributeString("", "Date", "", Converter.ToString(o.DateOrdered));
         writer.WriteStartElement("", "GrandTotal", "mvp-xml-templates");
         writer.WriteString(Converter.ToString(CalculateTotal(o)));
         writer.WriteEndElement();
         if (o.Items != null)            //;
         {
             foreach (Item i in o.Items) //;
             {
                 writer.WriteStartElement("", "Item", "mvp-xml-templates");
                 writer.WriteAttributeString("", "Id", "", Converter.ToString(i.ProductId));
                 writer.WriteAttributeString("", "SubTotal", "", Converter.ToString(i.Quantity * i.Price));
                 writer.WriteStartElement("", "Quantity", "mvp-xml-templates");
                 writer.WriteString(Converter.ToString(i.Quantity));
                 writer.WriteEndElement();
                 writer.WriteStartElement("", "Price", "mvp-xml-templates");
                 writer.WriteString(Converter.ToString(i.Price));
                 writer.WriteEndElement();
                 writer.WriteEndElement();
             } //;
         }     //;
         writer.WriteEndElement();
     }         //;
     writer.WriteEndElement();
 }
        protected override void FormatXml(XmlWriter writer, LoggingEvent loggingEvent)
        {
            writer.WriteStartElement("LogEntry");

            writer.WriteStartElement("Level");
            writer.WriteString(loggingEvent.Level.DisplayName);
            writer.WriteEndElement();

            writer.WriteStartElement("Message");
            writer.WriteString(loggingEvent.RenderedMessage);
            writer.WriteEndElement();

            writer.WriteStartElement("Details");
            if (loggingEvent.ExceptionObject != null)
                writer.WriteString(loggingEvent.ExceptionObject.ToString());
            writer.WriteEndElement();

            writer.WriteStartElement("StackTrace");
            if (loggingEvent.ExceptionObject != null)
                writer.WriteString(string.IsNullOrEmpty(loggingEvent.ExceptionObject.StackTrace) ? string.Empty : loggingEvent.ExceptionObject.StackTrace);
            writer.WriteEndElement();

            writer.WriteStartElement("TimeStamp");
            writer.WriteString(loggingEvent.TimeStamp.ToString("dd/MM/yyyy HH:mm:ss"));
            writer.WriteEndElement();

            writer.WriteEndElement();
        }
Example #9
0
        public void WriteXml(System.Xml.XmlWriter writer)
        {
            foreach (KeyValue key in this.Keys)
            {
                writer.WriteStartElement("item");

                //Write key
                writer.WriteStartElement("key");
                writer.WriteStartElement("keyValue");
                if (key.FunctionKey != null)
                {
                    writer.WriteStartElement("functionKey");
                    writer.WriteString(key.FunctionKey.Value.ToString());
                    writer.WriteEndElement();
                }
                if (key.String != null)
                {
                    writer.WriteStartElement("str");
                    writer.WriteCData(key.String);
                    writer.WriteEndElement();
                }
                writer.WriteEndElement();
                writer.WriteEndElement();

                //Write value (as ticks because TimeSpan is not XML serialisable)
                TimeSpan value = this[key];
                writer.WriteStartElement("value");
                writer.WriteStartElement("ticks");
                writer.WriteString(XmlConvert.ToString(value));
                writer.WriteEndElement();
                writer.WriteEndElement();

                writer.WriteEndElement();
            }
        }
Example #10
0
        public void WriteXml(System.Xml.XmlWriter writer)
        {
            foreach (KeyValue key in this.Keys)
            {
                writer.WriteStartElement("item");

                //Write key
                writer.WriteStartElement("key");
                writer.WriteStartElement("keyValue");
                if (key.FunctionKey != null)
                {
                    writer.WriteStartElement("functionKey");
                    writer.WriteString(key.FunctionKey.Value.ToString());
                    writer.WriteEndElement();
                }
                if (key.String != null)
                {
                    writer.WriteStartElement("str");
                    writer.WriteCData(key.String);
                    writer.WriteEndElement();
                }
                writer.WriteEndElement();
                writer.WriteEndElement();
                writer.WriteStartElement("value");
                writer.WriteStartElement("ticks");
                writer.WriteString(this[key]);
                writer.WriteEndElement();
                writer.WriteEndElement();

                writer.WriteEndElement();
            }
        }
 public void WriteXml(System.Xml.XmlWriter writer)
 {
     writer.WriteElementString("aggregate", Aggregate.ToString().ToLowerInvariant());
     if (Assemblies != null)
     {
         writer.WriteStartElement("assemblies");
         foreach (var assembly in Assemblies)
         {
             writer.WriteStartElement("assembly");
             writer.WriteStartAttribute("ref");
             writer.WriteString(assembly);
             writer.WriteEndAttribute();
             writer.WriteEndElement();
         }
         writer.WriteEndElement();
     }
     if (Dependencies != null)
     {
         writer.WriteStartElement("dependencies");
         foreach (var dependency in Dependencies)
         {
             writer.WriteStartElement("dependency");
             writer.WriteStartAttribute("ref");
             writer.WriteString(dependency);
             writer.WriteEndAttribute();
             writer.WriteEndElement();
         }
         writer.WriteEndElement();
     }
 }
Example #12
0
 protected override void WriteElementProperties(System.Xml.XmlWriter writer, object obj, ITypeSerializationInfo info, XmlSerializationContext context)
 {
     if (info.DefaultProperty != null)
     {
         var content = info.DefaultProperty.GetValue(obj, context);
         if (info.DefaultProperty.ShouldSerializeValue(obj, content))
         {
             writer.WriteString(GetAttributeValue(content, info.DefaultProperty.PropertyType, false, context));
         }
     }
     foreach (XmlPropertySerializationInfo pi in info.ElementProperties)
     {
         var value = pi.GetValue(obj, context);
         if (pi.ShouldSerializeValue(obj, value))
         {
             if (pi.PropertyType.IsCollection)
             {
                 var collectionType = pi.PropertyType.CollectionItemType.Type;
                 foreach (object item in value as IEnumerable)
                 {
                     writer.WriteStartElement(pi.NamespacePrefix, pi.ElementName, pi.Namespace);
                     var itemType = item.GetType();
                     var itemInfo = GetSerializationInfo(itemType, true);
                     if (itemType != collectionType)
                     {
                         WriteTypeQualifier(writer, itemInfo);
                     }
                     if (itemInfo.IsStringConvertible)
                     {
                         writer.WriteString(itemInfo.ConvertToString(item));
                     }
                     else
                     {
                         Serialize(item, writer, pi, false, pi.IdentificationMode, context);
                     }
                     writer.WriteEndElement();
                 }
             }
             else
             {
                 writer.WriteStartElement(pi.NamespacePrefix, pi.ElementName, pi.Namespace);
                 if (value != null)
                 {
                     var type = value.GetType();
                     if (type != pi.PropertyType.Type.GetImplementationType())
                     {
                         WriteTypeQualifier(writer, GetSerializationInfo(type, true));
                     }
                 }
                 else
                 {
                     throw new NotImplementedException();
                 }
                 Serialize(value, writer, pi, false, pi.IdentificationMode, context);
                 writer.WriteEndElement();
             }
         }
     }
 }
Example #13
0
 protected override void WriteXmlData(XmlWriter writer)
 {
     var data = (WhoAndWhenData)GetData();
     writer.WriteStartElement("Who");
     writer.WriteString(data.Who == null ? string.Empty : data.Who.Path);
     writer.WriteEndElement();
     writer.WriteStartElement("When");
     writer.WriteString(XmlConvert.ToString(data.When, XmlDateTimeSerializationMode.Unspecified));
     writer.WriteEndElement();
 }
 internal override void WriteTo(XmlWriter writer)
 {
     base.WriteTo(writer);
     writer.WriteStartElement("MessageNumber");
     writer.WriteString(this.sequenceNumber.ToString(CultureInfo.InvariantCulture));
     writer.WriteEndElement();
     writer.WriteStartElement("LastMessage");
     writer.WriteString(this.isLast.ToString(CultureInfo.InvariantCulture));
     writer.WriteEndElement();
 }
Example #15
0
        public override void writeToXml(XmlWriter xmlWriter)
        {
            xmlWriter.WriteStartElement(CENTER);
            xmlWriter.WriteString(center.X + "," + center.Y + "," + center.Z);
            xmlWriter.WriteEndElement();

            xmlWriter.WriteStartElement(QUATERNIONS);
            xmlWriter.WriteString(quaternion.W + "," + quaternion.X + "," + quaternion.Y + "," + quaternion.Z);
            xmlWriter.WriteEndElement();
        }
Example #16
0
        public override bool ExportAsXml(XmlWriter writer)
        {
            writer.WriteStartElement("name");
            writer.WriteString(Name);
            writer.WriteEndElement();

            writer.WriteStartElement("data");
            writer.WriteString(Data);
            writer.WriteEndElement();
            return true;
        }
 protected override void InnerSerialize(System.Xml.XmlWriter writer)
 {
     if (_dataValue)
     {
         writer.WriteString("B");
     }
     else
     {
         writer.WriteString("A");
     }
 }
Example #18
0
 private void WriteSpellXml(XmlWriter w, string name, SpellDescription spell)
 {
     string shortName = Regex.Replace(name, "[^\\w]", "").ToLower();
     w.WriteStartElement(shortName);
     w.WriteStartElement("name");
     w.WriteAttributeString("type", "string");
     w.WriteString(name);
     w.WriteEndElement(); // name
     w.WriteStartElement("school");
     w.WriteAttributeString("type", "string");
     w.WriteString(spell.School);
     w.WriteEndElement(); // school
     w.WriteStartElement("level");
     w.WriteAttributeString("type", "string");
     w.WriteString(spell.Level);
     w.WriteEndElement(); // level
     w.WriteStartElement("components");
     w.WriteAttributeString("type", "string");
     w.WriteString(spell.Components);
     w.WriteEndElement(); // components
     w.WriteStartElement("castingtime");
     w.WriteAttributeString("type", "string");
     w.WriteString(spell.CastingTime);
     w.WriteEndElement(); // castingtime
     w.WriteStartElement("range");
     w.WriteAttributeString("type", "string");
     w.WriteString(spell.Range);
     w.WriteEndElement(); // range
     w.WriteStartElement("effect");
     w.WriteAttributeString("type", "string");
     w.WriteString(spell.Effect);
     w.WriteEndElement(); // effect
     w.WriteStartElement("duration");
     w.WriteAttributeString("type", "string");
     w.WriteString(spell.Duration);
     w.WriteEndElement(); // duration
     w.WriteStartElement("save");
     w.WriteAttributeString("type", "string");
     w.WriteString(spell.Save);
     w.WriteEndElement(); // save
     w.WriteStartElement("sr");
     w.WriteAttributeString("type", "string");
     w.WriteString(spell.AllowSpellResistance ? "Yes" : "No");
     w.WriteEndElement(); // sr
     w.WriteStartElement("description");
     w.WriteAttributeString("type", "formattedtext");
     var description = Regex.Replace(spell.LongDescription, @"[\r\n]+", "");
     // replace HTML tags with their lowercase versions (formattedtext is case sensitive...)
     // we don't support very many; h1, p, b, i, u, table, tr, td
     description = Regex.Replace(description, @"<[^<>]+>", m => { return m.Value.ToLower(); });
     w.WriteRaw(description);
     w.WriteEndElement(); // description
     w.WriteStartElement("shortdescription");
     w.WriteAttributeString("type", "string");
     w.WriteString(spell.ShortDescription);
     w.WriteEndElement(); // shortdescription
     w.WriteEndElement(); // <shortName>
 }
Example #19
0
 private static void WriteKeyValue(XmlWriter writer, string key, object value)
 {
     if (value.GetType() == typeof(string))
     {
         writer.WriteStartElement("String");
         if (key != null)
             writer.WriteAttributeString("Key", key);
         writer.WriteString((string)value);
         writer.WriteEndElement();
     }
     else if (value.GetType() == typeof(bool))
     {
         writer.WriteStartElement("Boolean");
         if (key != null)
             writer.WriteAttributeString("Key", key);
         writer.WriteString(value.ToString());
         writer.WriteEndElement();
     }
     else if (value.GetType() == typeof(DateTime))
     {
         writer.WriteStartElement("DateTime");
         if (key != null)
             writer.WriteAttributeString("Key", key);
         writer.WriteString(((DateTime)value).ToString("G"));
         writer.WriteEndElement();
     }
     else if (value.GetType() == typeof(TimeSpan))
     {
         writer.WriteStartElement("TimeSpan");
         if (key != null)
             writer.WriteAttributeString("Key", key);
         writer.WriteString(((TimeSpan)value).ToString("G"));
         writer.WriteEndElement();
     }
     else if (value.GetType() == typeof(int))
     {
         writer.WriteStartElement("Int32");
         if (key != null)
             writer.WriteAttributeString("Key", key);
         writer.WriteString(((int)value).ToString());
         writer.WriteEndElement();
     }
     else if (value.GetType() == typeof(List<object>))
     {
         WriteArray(writer, key, (List<object>)value);
     }
     else if (value.GetType() == typeof(Dictionary<string, object>))
     {
         WriteDict(writer, key, (Dictionary<string, object>)value);
     }
 }
		/// <summary>
		/// Write a string to an XmlWriter
		/// </summary>
		/// <param name="writer">the writer to write to</param>
		/// <param name="text">the string to write</param>
		/// <remarks>
		/// The test is escaped either using XML escape entities
		/// or using CDATA sections.
		/// </remarks>
		public static void WriteEscapedXmlString(XmlWriter writer, string text)
		{
			// Write either escaped text or CDATA sections

			int weightCData = 12 * (1 + CountSubstrings(text, CDATA_END));
			int weightStringEscapes = 3*(CountSubstrings(text, "<") + CountSubstrings(text, ">")) + 4*CountSubstrings(text, "&");

			if (weightStringEscapes <= weightCData)
			{
				// Write string using string escapes
				writer.WriteString(text);
			}
			else
			{
				// Write string using CDATA section

				int end = text.IndexOf(CDATA_END);
	
				if (end < 0) 
				{
					writer.WriteCData(text);
				}
				else
				{
					int start = 0;
					while (end > -1) 
					{
						writer.WriteCData(text.Substring(start, end - start));
						if (end == text.Length - 3)
						{
							start = text.Length;
							writer.WriteString(CDATA_END);
							break;
						}
						else
						{
							writer.WriteString(CDATA_UNESCAPABLE_TOKEN);
							start = end + 2;
							end = text.IndexOf(CDATA_END, start);
						}
					}
	
					if (start < text.Length)
					{
						writer.WriteCData(text.Substring(start));
					}
				}
			}
		}
Example #21
0
        public void WriteXml(System.Xml.XmlWriter writer)
        {
            foreach (String key in this.Keys)
            {
                writer.WriteStartElement("Property");
                writer.WriteAttributeString("Name", this[key].name);
                if (this[key].type == typeof(string))
                {
                    writer.WriteAttributeString("Type", "string");
                }
                if (this[key].type == typeof(bool))
                {
                    writer.WriteAttributeString("Type", "bool");
                }
                if (this[key].type == typeof(Vector2))
                {
                    writer.WriteAttributeString("Type", "Vector2");
                }
                if (this[key].type == typeof(Color))
                {
                    writer.WriteAttributeString("Type", "Color");
                }
                if (this[key].type == typeof(Component))
                {
                    writer.WriteAttributeString("Type", "Item");
                }

                writer.WriteAttributeString("Description", this[key].description);

                if (this[key].type == typeof(Component))
                {
                    Component item = (Component)this[key].value;
                    if (item != null)
                    {
                        writer.WriteString(item.Name);
                    }
                    else
                    {
                        writer.WriteString("$null$");
                    }
                }
                else
                {
                    XmlSerializer valueSerializer = new XmlSerializer(this[key].type);
                    valueSerializer.Serialize(writer, this[key].value);
                }
                writer.WriteEndElement();
            }
        }
Example #22
0
		public void SaveXml(CompilationUnit cu)
		{
            try
            {
                this.cu = cu;
                is_assembly = cu.SyntaxTree is SyntaxTree.program_module || Compiler.is_dll(cu.SyntaxTree);
                XmlWriterSettings settings = new XmlWriterSettings();
                settings.Encoding = Encoding.UTF8;
                settings.Indent = true;
                xtw = XmlTextWriter.Create(Path.ChangeExtension(cu.UnitName, ".xml"), settings);
                unit_name = Path.GetFileNameWithoutExtension(cu.UnitName);
                xtw.WriteStartDocument();
                xtw.WriteStartElement("doc");
                if (is_assembly)
                {
                    xtw.WriteStartElement("assembly");
                    xtw.WriteStartElement("name");
                    xtw.WriteString(Path.GetFileNameWithoutExtension(cu.UnitName));
                    xtw.WriteEndElement();
                    xtw.WriteEndElement();
                }
                else
                {
                    xtw.WriteStartElement("unit");
                    xtw.WriteStartAttribute("name");
                    //xtw.WriteString((cu.SemanticTree as common_unit_node).unit_name);
                    xtw.WriteString(Path.GetFileNameWithoutExtension(cu.UnitName));
                    xtw.WriteEndAttribute();
                    xtw.WriteString(cu.SemanticTree.documentation);
                    xtw.WriteEndElement();
                }
                SaveMembers();
                xtw.WriteEndElement();
                xtw.Flush();
            }
            catch (Exception e)
            {

            }
			try
			{
				if (xtw != null)
					xtw.Close();
			}
			catch
			{
				
			}
		}
Example #23
0
 /// <summary>
 /// Write as text
 /// </summary>
 internal override void WriteText(System.Xml.XmlWriter w)
 {
     if (this.Value.Scheme == "http" ||
         this.Value.Scheme == "https")
     {
         w.WriteStartElement("a", NS_XHTML);
         w.WriteAttributeString("href", this.Value.ToString());
         w.WriteString(this.Value.ToString());
         w.WriteEndElement(); // a
     }
     else
     {
         w.WriteString(this.Value.ToString());
     }
 }
Example #24
0
        protected override void FormatXml(XmlWriter writer, LoggingEvent loggingEvent)
        {
            writer.WriteStartElement("LogEntry");

              writer.WriteStartElement("Level");
              writer.WriteString(loggingEvent.Level.DisplayName);
              writer.WriteEndElement();

              writer.WriteStartElement("Message");
              writer.WriteCData(loggingEvent.RenderedMessage);
              writer.WriteEndElement();

              writer.WriteStartElement("Details");
              if (loggingEvent.ExceptionObject != null)
            writer.WriteCData(loggingEvent.ExceptionObject.ToString());
              writer.WriteEndElement();

              writer.WriteStartElement("StackTrace");

              if (loggingEvent.ExceptionObject != null)
              {
            writer.WriteCData(string.IsNullOrEmpty(loggingEvent.ExceptionObject.StackTrace) ? string.Empty : loggingEvent.ExceptionObject.StackTrace);
            //Exception Details
            {
              // Get stack trace for the exception with source file information
              var st = new StackTrace(loggingEvent.ExceptionObject, true);
              // Get the top stack frame
              var frame = st.GetFrame(0);

              if (frame != null)
              {
            // Get the line number from the stack frame
            var line = frame.GetFileLineNumber();

            string error_dtls = string.Format("\nFile: {0} -> Line:{1}", frame.GetFileName(), frame.GetFileLineNumber());
            writer.WriteCData(error_dtls);
              }
            }

            writer.WriteEndElement();
              }

              writer.WriteStartElement("TimeStamp");
              writer.WriteString(loggingEvent.TimeStamp.ToString("dd/MM/yyyy HH:mm:ss"));
              writer.WriteEndElement();

              writer.WriteEndElement();
        }
Example #25
0
        public void WriteXml(System.Xml.XmlWriter writer)
        {
            XmlSerializer keySerializer   = new XmlSerializer(typeof(string));
            XmlSerializer valueSerializer = new XmlSerializer(typeof(T));

            foreach (string key in this.Keys)
            {
                writer.WriteStartElement("item");
                writer.WriteAttributeString("key", key);

                if (this[key] is string)
                {
                    writer.WriteString(this[key].ToString());
                }
                else
                {
                    XmlSerializer xmlSerializer = new XmlSerializer(typeof(T));
                    using (StringWriter textWriter = new StringWriter())
                    {
                        xmlSerializer.Serialize(textWriter, this[key]);
                        XmlDocument doc = new XmlDocument();
                        doc.LoadXml(textWriter.ToString());

                        writer.WriteRaw(doc.GetElementsByTagName(typeof(T).Name)[0].InnerXml);
                    }
                }

                writer.WriteEndElement();
            }
        }
Example #26
0
        public static void ProcessDirectory(string targetDirectory, XmlWriter writer)
        {
            // Process the list of files found in the directory.
            string[] fileEntries = Directory.GetFiles(targetDirectory);

            writer.WriteStartElement("dir");

            foreach (string fileName in fileEntries)
            {
                writer.WriteStartElement("file");
                writer.WriteString(fileName);
                writer.WriteEndElement();
            }

            // Recurse into subDirectories of this directory.
            string[] subDirectoryEntries = Directory.GetDirectories(targetDirectory);

            foreach (string subDirectory in subDirectoryEntries)
            {
                writer.WriteStartElement("dir");
                writer.WriteAttributeString("dirName", subDirectory);
                ProcessDirectory(subDirectory, writer);
                writer.WriteEndElement();
            }

            writer.WriteEndElement();
        }
Example #27
0
        /// <summary>
        /// Converts the given value to the ATOM string representation
        /// and uses the writer to write it.
        /// </summary>
        /// <param name="writer">The writer to write the stringified value.</param>
        /// <param name="value">The value to be written.</param>
        /// <param name="expectedType">The expected resource type of the value or null if no metadata is available.</param>
        internal static void WritePrimitiveValue(XmlWriter writer, object value, ResourceType expectedType)
        {
            DebugUtils.CheckNoExternalCallers();
            Debug.Assert(value != null, "value != null");
            
            string result;
            bool preserveWhitespace;
            if (!TryConvertPrimitiveToString(value, out result, out preserveWhitespace))
            {
                throw new ODataException(Strings.AtomValueUtils_CannotConvertValueToAtomPrimitive(value.GetType().FullName));
            }

            if (expectedType != null)
            {
                ValidationUtils.ValidateIsExpectedPrimitiveType(value, expectedType);
            }

            if (preserveWhitespace)
            {
                writer.WriteAttributeString(
                    AtomConstants.XmlNamespacePrefix,
                    AtomConstants.XmlSpaceAttributeName,
                    AtomConstants.XmlNamespace,
                    AtomConstants.XmlPreserveSpaceAttributeValue);
            }

            writer.WriteString(result);
        }
		protected override void WriteValue(XmlWriter writer, object value)
		{
			IDictionary dictionary = (IDictionary) value;
			foreach (object key in dictionary.Keys)
			{
				object target = dictionary[key];

				// any way to refactor code block?
				ReflectorTypeAttribute typeAttribute = ReflectorTypeAttribute.GetAttribute(target);
				if (typeAttribute == null)
				{
					writer.WriteStartElement(elementName);
					writer.WriteAttributeString(attribute.Key, key.ToString());
					writer.WriteString(target.ToString());
					writer.WriteEndElement();
				}
				else
				{
					writer.WriteStartElement(typeAttribute.Name);
					writer.WriteAttributeString(attribute.Key, key.ToString());

					XmlTypeSerialiser serialiser = (XmlTypeSerialiser) typeAttribute.CreateSerialiser(target.GetType());
					serialiser.WriteMembers(writer, target);

					writer.WriteEndElement();
				}
			}
		}
Example #29
0
 public void WriteXml(System.Xml.XmlWriter writer)
 {
     Array.ForEach(
         Fields,
         delegate(EntityDbField item) {
         writer.WriteStartElement(XmlConvert.EncodeLocalName(item.DbName));
         writer.WriteAttributeString("length", item.DbLength.ToString());
         writer.WriteAttributeString("dbType", item.DbType.ToString());
         object val = GetValueForDbField(item);
         if (null != val)
         {
             try {
                 writer.WriteValue(GetValueForDbField(item));
             }
             catch {
                 writer.WriteString(
                     typeof(XmlConvert).InvokeMember(
                         "ToString",
                         BindingFlags.Static | BindingFlags.Public | BindingFlags.InvokeMethod,
                         null,
                         null,
                         new Object[] { GetValueForDbField(item) }).ToString());
             }
         }
         writer.WriteEndElement();
     });
 }
        public static void WriteMapping(XmlWriter writer, ISymbolMapping mapping)
        {
            writer.WriteStartElement(mapping.GetType().Name);
            writer.WriteAttributeString("Name", mapping.Name);

            var replaceMapping = mapping as ReplaceMapping;
            if (replaceMapping != null)
            {
                foreach (var replacement in replaceMapping.Replacements.OrderBy(kv => kv.Key))
                {
                    writer.WriteStartElement("Replacement");
                    writer.WriteAttributeString("Replace", replacement.Key);
                    writer.WriteAttributeString("With", replacement.Value);
                    writer.WriteEndElement();
                }
                var scriptedMapping = replaceMapping as ScriptedMapping;
                if (scriptedMapping != null)
                {
                    writer.WriteStartElement("ScriptBody");
                    writer.WriteString(scriptedMapping.ScriptBody);
                    writer.WriteEndElement();
                }
            }
            writer.WriteEndElement();
        }
Example #31
0
        // Originally this class used the XML attributes to serialize itself
        // via an XmlSerializer, but that turns out not the work (see the comments
        // in EventWriter). So instead we have localized all the XML related code
        // in this one method. It turns out to be simpler to understand, too.
        public void ToXml(XmlWriter writer)
        {
            Contract.Requires(writer != null);

            writer.WriteStartElement("event");
            if (Stanza != null) writer.WriteAttributeString("stanza", Stanza);
            if (Unbroken) writer.WriteAttributeString("unbroken", "1");

            if (Data != null) WriteTextElement(writer, "data", Data);
            if (Source != null) WriteTextElement(writer, "source", Source);
            if (SourceType != null) WriteTextElement(writer, "sourcetype", SourceType);
            if (Index != null) WriteTextElement(writer, "index", Index);
            if (Host != null) WriteTextElement(writer, "host", Host);

            if (Time.HasValue)
            {
                double timestamp = (double)(Time.Value.Ticks - ticksSinceEpoch) / TimeSpan.TicksPerSecond;
                writer.WriteStartElement("time");
                writer.WriteString(timestamp.ToString());
                writer.WriteEndElement();
            }

            if (Done)
            {
                writer.WriteStartElement("done");
                writer.WriteEndElement();
            }

            writer.WriteEndElement();
        }
Example #32
0
		internal static void WriteElement(XmlWriter writer, XElement element)
		{
			if (WriteWholeNode(element))
			{
				// Write entire element in one gulp, to avoid eating needed spaces in <Run> elements.
				element.WriteTo(writer);
			}
			else
			{
				writer.WriteStartElement(element.Name.LocalName);
				foreach (var attribute in element.Attributes())
				{
					writer.WriteAttributeString(attribute.Name.LocalName, attribute.Value);
				}
				if (element.HasElements)
				{
					foreach (var childNode in element.Elements().ToArray())
					{
						// Recurse on down to the bottom.
						WriteElement(writer, childNode);
						childNode.Remove();
					}
				}
				else
				{
					if (!string.IsNullOrEmpty(element.Value))
						writer.WriteString(element.Value);
				}
				writer.WriteEndElement();
			}
		}
Example #33
0
 private void WriteIntFlags2Content(XmlTextWriter writer, MetaInt32_Enum3 intValue)
 {
     if (intValue.Value != 0)
     {
         StringBuilder sb = new StringBuilder();
         for (int i = 0; i < 32; i++)
         {
             if ((intValue.Value & (1 << i)) != 0)
             {
                 if (intValue.info != null)
                 {
                     foreach (var xy in intValue.info.Entries)
                     {
                         if (xy.EntryValue == i)
                         {
                             sb.Append(" ");
                             sb.Append(GetFlagNameForHash(xy.EntryNameHash));
                         }
                     }
                 }
                 else
                 {
                     sb.Append(" flag_index_");
                     sb.Append(i.ToString());
                 }
             }
         }
         writer.WriteString(sb.ToString().Trim());
     }
 }
Example #34
0
        public static void WriteLdmlText(XmlWriter writer, string text)
        {
            // Not all Unicode characters are valid in an XML document, so we need to create
            // the <cp hex="X"> elements to replace the invalid characters.
            // Note: While 0xD (carriage return) is a valid XML character, it is automatically
            // either dropped or coverted to 0xA by any conforming XML parser, so we also make a <cp>
            // element for that one.
            StringBuilder sb = new StringBuilder(text.Length);
            for (int i=0; i < text.Length; i++)
            {
                int code = Char.ConvertToUtf32(text, i);
                if ((code == 0x9) ||
                    (code == 0xA) ||
                    (code >= 0x20 && code <= 0xD7FF) ||
                    (code >= 0xE000 && code <= 0xFFFD) ||
                    (code >= 0x10000 && code <= 0x10FFFF))
                {
                    sb.Append(Char.ConvertFromUtf32(code));
                }
                else
                {
                    writer.WriteString(sb.ToString());
                    writer.WriteStartElement("cp");
                    writer.WriteAttributeString("hex", String.Format("{0:X}", code));
                    writer.WriteEndElement();
                    sb = new StringBuilder(text.Length - i);
                }

                if (Char.IsSurrogatePair(text, i))
                {
                    i++;
                }
            }
            writer.WriteString(sb.ToString());
        }
Example #35
0
        void IXmlSerializable.WriteXml(XmlWriter writer)
        {
            if (writer == null) { throw new ArgumentNullException(nameof(writer)); }

            writer.WriteAttributeString("IsPinned", IsPinned.ToString());
            writer.WriteString(Path);
        }
Example #36
0
        public void WriteXml(XmlWriter writer)
        {
            if (writer == null) { throw new ArgumentException("writer"); }

            writer.WriteAttributeString("IsPinned", isPinned.ToString());
            writer.WriteString(path);
        }
Example #37
0
 private void createElement(XmlWriter writer, string whitespace, string name, string value)
 {
     writer.WriteWhitespace(whitespace);
     writer.WriteStartElement(name);
     writer.WriteString(value);
     writer.WriteEndElement();
 }
Example #38
0
		private static void WriteShapes(XmlWriter writer, GraphAbstract g)
		{
			writer.WriteStartElement("g");
			for(int k=0; k<g.Shapes.Count; k++) //<rect x="1140" y="30" width="100" height="20" style="fill: url(#two_hues); stroke: black;"/>
			{
				writer.WriteStartElement("rect");
				writer.WriteAttributeString("x", g.Shapes[k].X.ToString());
				writer.WriteAttributeString("y", g.Shapes[k].Y.ToString());
				writer.WriteAttributeString("width", g.Shapes[k].Width.ToString());
				writer.WriteAttributeString("height", g.Shapes[k].Height.ToString());
				writer.WriteAttributeString("rx", "2");//rounded rectangle				

				//writer.WriteAttributeString("style", "fill: url(#two_hues); stroke: black;");
				writer.WriteAttributeString("fill",  string.Concat("#", (g.Shapes[k].ShapeColor.ToArgb() & 0x00FFFFFF).ToString("X6")) );
				writer.WriteEndElement();
				
				//<text text-anchor="middle" x="{$x+50}" y="{$y+15}">
				writer.WriteStartElement("text");
				writer.WriteAttributeString("x", Convert.ToString(g.Shapes[k].X + 10));
				writer.WriteAttributeString("y", Convert.ToString(g.Shapes[k].Y + 15));
				writer.WriteAttributeString("text-anchor", "start");			
				writer.WriteAttributeString("font-size", "9");
				writer.WriteString(g.Shapes[k].Text);
				writer.WriteEndElement();
				
			}
			writer.WriteEndElement();
		}
 internal override void WriteTo(XmlWriter writer)
 {
     base.WriteTo(writer);
     writer.WriteStartElement("Identifier");
     writer.WriteString(this.id.ToString());
     writer.WriteEndElement();
 }
Example #40
0
 /// <summary>
 /// Saving the object into an xml node
 /// </summary>
 /// <param name="comp">this compiler</param>
 /// <param name="writer">Xml writer object</param>
 /// <param name="child">html child for nested objects</param>
 public void Save(ICompilateur comp, System.Xml.XmlWriter writer, ref System.Windows.Forms.HtmlElement child)
 {
     writer.WriteStartElement("createmop");
     writer.WriteAttributeString("language", this.language);
     writer.WriteAttributeString("name", this.name);
     if (this.indent > 0)
     {
         writer.WriteAttributeString("indent", this.indent.ToString());
     }
     writer.WriteStartElement("legendes");
     this.legendes.Save(writer);
     writer.WriteEndElement();
     writer.WriteStartElement("references");
     foreach (string param in this.refs)
     {
         writer.WriteStartElement("ref");
         writer.WriteString(param);
         writer.WriteEndElement();
     }
     writer.WriteEndElement();
     writer.WriteStartElement("code");
     writer.WriteRaw(this.xmlCode);
     writer.WriteEndElement();
     writer.WriteEndElement();
     child = child.NextSibling;
 }
Example #41
0
        /// <summary>
        /// Creates XML elements from the data of the system.
        /// </summary>
        /// <param name="xmlWriter">Object with the XML message to add new information and return to client side</param>
        /// <param name="val">Value to be puted inside the XML message</param>
        /// <param name="dtdVersion">Version of the DTD that follows the XML message</param>
        /// <param name="xmlElement">Element of the XML that is checked</param>
        public static void ON2XML(XmlWriter xmlWriter, ONReal val, double dtdVersion, string xmlElement)
        {
            if (val == null)
            {
                if (xmlElement == ONXml.XMLTAG_V)
                    xmlWriter.WriteElementString(xmlElement, "");
                else
                    xmlWriter.WriteElementString(ONXml.XMLTAG_NULL, null);
            }
            else
            {
                if (dtdVersion < 2.0) // Apply the locale format
                    xmlWriter.WriteElementString(xmlElement, val.TypedValue.ToString("0.##############"));
                else
                {
                    xmlWriter.WriteStartElement(xmlElement);
                    if (xmlElement == ONXml.XMLTAG_OIDFIELD && dtdVersion > 2.0)
                        xmlWriter.WriteAttributeString("Type", "real");

                    string lValue = Pack(val);
                    xmlWriter.WriteString(lValue);
                    xmlWriter.WriteEndElement();
                }
            }
        }
Example #42
0
 public static void WriteXmlLogStart(XmlWriter xw)
 {
     xw.WriteStartDocument();
     xw.WriteStartElement("LogEntries");
     xw.WriteString("\r\n");
     xw.WriteComment(StaticVariables.Logo(false) + "\r\n" + CurrentQuery + "\r\n"); //+ CurrentEntryCount + "\r\n");
 }
Example #43
0
 private void WriteStringContent(XmlTextWriter writer, PsoString3 value)
 {
     if (value.Value != null)
     {
         writer.WriteString(value.Value.Replace("\0", ""));
     }
 }
Example #44
0
 public void WriteXml(XmlWriter xw)
 {
     xw.WriteStartElement(VerificationMessage._xml_tag);
     xw.WriteAttributeString(VerificationMessage._xml_message_sourcefile_attr, this.sourceLabel);
     xw.WriteString(this.message);
     xw.WriteEndElement();
 }
Example #45
0
 private void WriteStringContent(XmlTextWriter writer, PsoString8 value)
 {
     if (value.Value != 0)
     {
         writer.WriteString(GetNameForHash(value.Value));
     }
 }
        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();
        }
Example #47
0
        public new void WriteXml(System.Xml.XmlWriter writer)
        {
            base.WriteXml(writer);

            writer.WriteElementString("PollType", PollType.ToString("D"));
            writer.WriteElementString("ShowAnswerCount", ShowAnswerCount.ToString("D"));
            writer.WriteElementString("ShowResult", ShowResult.ToString("D"));
            writer.WriteElementString("PollLayout", PollLayout.ToString("D"));
            writer.WriteElementString("AnonymousAllowed", AnonymousAllowed.ToString());
            writer.WriteElementString("HasAnswers", HasAnswers.ToString());
            writer.WriteElementString("AnswerAnonnymous", AnswerAnonnymous.ToString());
            writer.WriteElementString("AnswerRegisterd", AnswerRegisterd.ToString());
            writer.WriteElementString("AnswerTotal", AnswerTotal.ToString());
            writer.WriteElementString("TextRight", TextRight);
            writer.WriteElementString("TextFalse", TextFalse);
            writer.WriteElementString("TextPartially", TextPartially);

            writer.WriteStartElement("Answers");
            foreach (PollAnswer kvp in Answers)
            {
                writer.WriteStartElement("Answer");
                writer.WriteAttributeString("Position", kvp.Position.ToString());
                writer.WriteAttributeString("Anonnymous", kvp.Anonnymous.ToString());
                writer.WriteAttributeString("Registerd", kvp.Registerd.ToString());
                writer.WriteAttributeString("IsRight", kvp.IsRight.ToString());
                writer.WriteString(kvp.Answer);
                writer.WriteEndElement();
            }
            writer.WriteEndElement();
        }
Example #48
0
        private void WriteFlagsContent(XmlTextWriter writer, PsoFlagsInt value)
        {
            var sb = new StringBuilder();

            for (int i = 0; i < 32; i++)
            {
                if ((value.Value & (1 << i)) != 0)
                {
                    var machingFlagEntry = (PsoEnumEntryInfo)null;
                    foreach (var flagEntry in value.TypeInfo.Entries)
                    {
                        if (flagEntry.EntryKey == i)
                        {
                            machingFlagEntry = flagEntry;
                        }
                    }

                    var matchingFlagName = GetNameForHash(machingFlagEntry.EntryNameHash);
                    sb.Append(matchingFlagName + " ");
                }
            }

            var flagsString = sb.ToString().Trim();

            writer.WriteString(flagsString);
        }
Example #49
0
 public void Render(System.Xml.XmlWriter writer)
 {
     writer.WriteStartDocument(true);
     writer.WriteStartElement("", "Customer", "mvp-xml-templates");
     writer.WriteAttributeString("", "xmlns", "http://www.w3.org/2000/xmlns/", "mvp-xml-templates");
     writer.WriteAttributeString("", "Name", "", Converter.ToString(customer.LastName + ", " + customer.FirstName));
     writer.WriteStartElement("", "Orders", "mvp-xml-templates");
     foreach (Order o in customer.Orders)    //;
     {
         writer.WriteStartElement("", "Order", "mvp-xml-templates");
         writer.WriteAttributeString("", "Id", "", Converter.ToString(o.Id));
         writer.WriteAttributeString("", "Premium", "", Converter.ToString((o.GrandTotal > 10000)));
         writer.WriteStartElement("", "Items", "mvp-xml-templates");
         writer.WriteAttributeString("", "GrandTotal", "", Converter.ToString(CalculateTotals(o)));
         foreach (Item i in o.Items) //;
         {
             writer.WriteStartElement("", "Item", "mvp-xml-templates");
             writer.WriteAttributeString("", "Id", "", Converter.ToString(i.ProductId));
             writer.WriteAttributeString("", "SubTotal", "", Converter.ToString(i.Quantity * i.Price));
             writer.WriteEndElement();
         }//;
         writer.WriteEndElement();
         writer.WriteStartElement("", "Recipe", "http://schemas.microsoft.com/pag/gax-core");
         writer.WriteAttributeString("", "xmlns", "http://www.w3.org/2000/xmlns/", "http://schemas.microsoft.com/pag/gax-core");
         writer.WriteAttributeString("", "Name", "", "Foo");
         writer.WriteStartElement("", "Caption", "http://schemas.microsoft.com/pag/gax-core");
         writer.WriteString(Converter.ToString(o.DateOrdered));
         writer.WriteEndElement();
         writer.WriteStartElement("", "Description", "http://schemas.microsoft.com/pag/gax-core");
         writer.WriteString(("\n\t\t\t\t\tExample of escaping the curly braces: \n\t\t\t\t\tstring.Format(\""
                             + (Converter.ToString({ 0 })
Example #50
0
        private static void WriteElementTo(PmlElement Element, System.Xml.XmlWriter Writer)
        {
            switch (Element.Type)
            {
            case PmlType.Binary:
                Writer.WriteAttributeString("type", "binary");
                byte[] Bytes = Element.ToByteArray();
                Writer.WriteBase64(Bytes, 0, Bytes.Length);
                break;

            case PmlType.Collection:
                Writer.WriteAttributeString("type", "collection");
                foreach (PmlElement Child in (PmlCollection)Element)
                {
                    Writer.WriteStartElement("item");
                    WriteElementTo(Child, Writer);
                    Writer.WriteEndElement();
                }

                break;

            case PmlType.Dictionary:
                Writer.WriteAttributeString("type", "dictionary");
                foreach (KeyValuePair <string, PmlElement> Child in (PmlDictionary)Element)
                {
                    Writer.WriteStartElement(Child.Key);
                    WriteElementTo(Child.Value, Writer);
                    Writer.WriteEndElement();
                }

                break;

            case PmlType.Integer:
                Writer.WriteAttributeString("type", "integer");
                Writer.WriteString(Element.ToString());
                break;

            case PmlType.Null:
                Writer.WriteAttributeString("type", "null");
                break;

            case PmlType.String:
                Writer.WriteAttributeString("type", "string");
                Writer.WriteString(Element.ToString());
                break;
            }
        }
Example #51
0
        static private void WriteProperty(object record, PropertyInfo property, System.Xml.XmlWriter write)
        {
            write.WriteStartElement("param");
            write.WriteAttributeString("name", property.Name);
            string parameterType = PdkXmlSerializer.MapType(property.GetGetMethod().ReturnType);

            write.WriteAttributeString("type", parameterType);

            object val = property.GetValue(record, null);

            if (val != null)
            {
                if (parameterType == "record")
                {
                    WriteRecord(val, write);
                }
                else if (parameterType == "sequence")
                {
                    if (property.PropertyType == typeof(string[]))
                    {
                        write.WriteAttributeString(PdkXmlSerializer.SequenceTypeAttributename, PdkXmlSerializer.MapType(typeof(string)));
                        Array ar = (Array)val;
                        for (int i = 0; i < ar.Length; ++i)
                        {
                            write.WriteStartElement(PdkXmlSerializer.ItemElementname);
                            write.WriteString(ar.GetValue(i).ToString());
                            write.WriteEndElement();
                        }
                    }
                    else
                    {
                        write.WriteAttributeString(PdkXmlSerializer.SequenceTypeAttributename, PdkXmlSerializer.RecordElementname);
                        Array ar = (Array)val;
                        for (int i = 0; i < ar.Length; ++i)
                        {
                            write.WriteStartElement(PdkXmlSerializer.ItemElementname);
                            WriteRecord(ar.GetValue(i), write);
                        }
                    }
                }
                else
                {
                    write.WriteString(PdkXmlSerializer.SerializeValue(val));
                }
            }
            write.WriteEndElement();
        }
Example #52
0
 public virtual void WriteXml(System.Xml.XmlWriter writer)
 {
     writer.WriteStartElement("NestedWriteString");
     writer.WriteStartElement("container2");
     writer.WriteString("container2 content");
     writer.WriteEndElement(); //container2
     writer.WriteEndElement(); //NestedWriteString
 }
Example #53
0
 private void WriteDirectValue(CommenceValue v)
 {
     _xw.WriteStartElement(XmlConvert.EncodeLocalName(base.ExportHeaders[v.ColumnDefinition.ColumnIndex]));
     // only write if we have something
     if (!string.IsNullOrEmpty(v.DirectFieldValue))
     {
         // can we get away with writing the value or do we need to use CData?
         if (v.ColumnDefinition.CommenceFieldDefinition.MaxChars == CommenceLimits.MaxTextFieldCapacity)
         {
             _xw.WriteCData(v.DirectFieldValue);
         }
         else
         {
             _xw.WriteString(v.DirectFieldValue);
         }
     }
     _xw.WriteEndElement();
 }
Example #54
0
 private void WriteIntEnumContent(XmlTextWriter writer, MetaInt32_Enum1 intValue)
 {
     if (intValue.Value != -1)
     {
         var thehash = (int)0;
         foreach (var enty in intValue.info.Entries)
         {
             if (enty.EntryValue == intValue.Value)
             {
                 thehash = enty.EntryNameHash;
             }
         }
         writer.WriteString(GetEnumNameForHash(thehash));
     }
     else
     {
         writer.WriteString("enum_NONE");
     }
 }
Example #55
0
 public void WriteXml(System.Xml.XmlWriter writer)
 {
     foreach (string key in this.Keys)
     {
         writer.WriteStartElement(key);
         string value = this[key];
         writer.WriteString(value);
         writer.WriteEndElement();
     }
 }
Example #56
0
        private void ExportDataId(System.Xml.XmlWriter writer)
        {
            var data = GetData();
            var node = data as Node;

            if (node != null)
            {
                writer.WriteString(node.Id.ToString());
                return;
            }

            var nodeList = data as NodeList <Node>;

            if (nodeList != null)
            {
                writer.WriteString(String.Join(",", nodeList.GetIdentifiers()));
                return;
            }

            var nodeEnumerable = data as IEnumerable <Node>;

            if (nodeEnumerable != null)
            {
                writer.WriteString(String.Join(",", nodeEnumerable.Select(n => n.Id)));
                return;
            }

            var nodes = data as IEnumerable;

            if (nodes != null)
            {
                var ids = new List <int>();
                foreach (Node n in nodes)
                {
                    ids.Add(n.Id);
                }
                writer.WriteString(String.Join(",", ids));
                return;
            }

            throw ExportNotSupportedException(GetData());
        }
Example #57
0
 public void WriteXml(System.Xml.XmlWriter writer)
 {
     foreach (var key in this.Keys)
     {
         writer.WriteStartElement("item");
         writer.WriteAttributeString("key", key);
         string value = this[key];
         writer.WriteString(value);
         writer.WriteEndElement();
     }
 }
Example #58
0
 /// <summary>
 /// Write xml
 /// </summary>
 /// <param name="writer">Writer</param>
 public void WriteXml(System.Xml.XmlWriter writer)
 {
     if (string.IsNullOrWhiteSpace(value))
     {
         writer.WriteString(string.Empty);
     }
     else
     {
         writer.WriteCData("\n" + value + "\n");
     }
 }
Example #59
0
        public static void WriteX(this System.Xml.XmlWriter x, Label label)
        {
            var t = label.Text;

            x.WriteStartElement("Paragraph");
            x.WriteTextStyleAttributes(label.TextStyle);
            if (t != null)
            {
                x.WriteString(t);
            }
            x.WriteEndParagraph();
        }
Example #60
0
 public static void WriteRunValue(this System.Xml.XmlWriter x, string t)
 {
     x.WriteStartRun();
     if (t != null)
     {
         if (t.Length > 0)
         {
             x.WriteString(t);
         }
     }
     x.WriteEndRun();
 }