jsonwriter.cs

Open Flash Chart is a program for creating charts in Flash to display in Web pages. You can create b

						}
						case '\f':
						{
							this.writer.Write("\\f");
							continue;
						}
						case '\n':
						{
							this.writer.Write("\\n");
							continue;
						}
						case '\r':
						{
							this.writer.Write("\\r");
							continue;
						}
						case '\t':
						{
							this.writer.Write("\\t");
							continue;
						}
						default:
						{
							this.writer.Write("\\u{0:X4}", Char.ConvertToUtf32(value, i));
							continue;
						}
					}
				}
			}

			this.writer.Write(value.Substring(start, length-start));

			this.writer.Write(JsonReader.OperatorStringDelim);
		}

		#endregion Public Methods

		#region Primative Writer Methods

		public virtual void Write(bool value)
		{
			this.writer.Write(value ? JsonReader.LiteralTrue : JsonReader.LiteralFalse);
		}

		public virtual void Write(byte value)
		{
			this.writer.Write("{0:g}", value);
		}

		public virtual void Write(sbyte value)
		{
			this.writer.Write("{0:g}", value);
		}

		public virtual void Write(short value)
		{
			this.writer.Write("{0:g}", value);
		}

		public virtual void Write(ushort value)
		{
			this.writer.Write("{0:g}", value);
		}

		public virtual void Write(int value)
		{
			this.writer.Write("{0:g}", value);
		}

		public virtual void Write(uint value)
		{
			this.writer.Write("{0:g}", value);
		}

		public virtual void Write(long value)
		{
			this.writer.Write("{0:g}", value);
		}

		public virtual void Write(ulong value)
		{
			this.writer.Write("{0:g}", value);
		}

		public virtual void Write(float value)
		{
			if (this.StrictConformance && (Single.IsNaN(value) || Single.IsInfinity(value)))
			{
				this.writer.Write(JsonReader.LiteralNull);
			}
			else
			{
				this.writer.Write("{0:r}", value);
			}
		}

		public virtual void Write(double value)
		{
			if (this.StrictConformance && (Double.IsNaN(value) || Double.IsInfinity(value)))
			{
				this.writer.Write(JsonReader.LiteralNull);
			}
			else
			{
				this.writer.Write("{0:r}", value);
			}
		}

		public virtual void Write(decimal value)
		{
			this.writer.Write("{0:g}", value);
		}

		public virtual void Write(char value)
		{
			this.Write(new String(value, 1));
		}

		public virtual void Write(TimeSpan value)
		{
			this.Write(value.Ticks);
		}

		public virtual void Write(Uri value)
		{
			this.Write(value.ToString());
		}

		public virtual void Write(Version value)
		{
			this.Write(value.ToString());
		}

		public virtual void Write(XmlNode value)
		{
			// TODO: translate XML to JSON
			this.Write(value.OuterXml);
		}

		#endregion Primative Writer Methods

		#region Writer Methods

		protected internal virtual void WriteArray(IEnumerable value)
		{
			bool appendDelim = false;

			this.writer.Write(JsonReader.OperatorArrayStart);

			this.depth++;
			try
			{
				foreach (object item in value)
				{
					if (appendDelim)
					{
						this.writer.Write(JsonReader.OperatorValueDelim);
					}
					else
					{
						appendDelim = true;
					}

					this.WriteLine();
					this.Write(item, false);
				}
			}
			finally
			{
				this.depth--;
			}

			if (appendDelim)
			{
				this.WriteLine();
			}
			this.writer.Write(JsonReader.OperatorArrayEnd);
		}

		protected virtual void WriteObject(IDictionary value)
		{
			bool appendDelim = false;

			this.writer.Write(JsonReader.OperatorObjectStart);

			this.depth++;
			try
			{
				foreach (object name in value.Keys)
				{
					if (appendDelim)
					{
						this.writer.Write(JsonReader.OperatorValueDelim);
					}
					else
					{
						appendDelim = true;
					}

					this.WriteLine();
					this.Write((String)name);
					this.writer.Write(JsonReader.OperatorNameDelim);
					this.Write(value[name], true);
				}
			}
			finally
			{
				this.depth--;
			}

			if (appendDelim)
			{
				this.WriteLine();
			}
			this.writer.Write(JsonReader.OperatorObjectEnd);
		}

		protected virtual void WriteObject(object value)
		{
			bool appendDelim = false;

			this.writer.Write(JsonReader.OperatorObjectStart);

			this.depth++;
			try
			{
				Type objType = value.GetType();

				if (!String.IsNullOrEmpty(this.TypeHintName))
				{
					if (appendDelim)
					{
						this.writer.Write(JsonReader.OperatorValueDelim);
					}
					else
					{
						appendDelim = true;
					}

					this.WriteLine();
					this.Write(this.TypeHintName);
					this.writer.Write(JsonReader.OperatorNameDelim);
					this.Write(objType.FullName, true);
				}

				// serialize public properties
				PropertyInfo[] properties = objType.GetProperties();
				foreach (PropertyInfo property in properties)
				{
					if (!property.CanWrite || !property.CanRead)
					{
						continue;
					}

					if (this.IsIgnored(objType, property, value))
					{
						continue;
					}

					object propertyValue = property.GetValue(value, null);

                    if ((propertyValue == null) && SkipNullValue)
                    {
                        continue;
                    }

					if (this.IsDefaultValue(property, propertyValue))
					{
						continue;
					}

					if (appendDelim)
					{
						this.writer.Write(JsonReader.OperatorValueDelim);
					}
					else
					{
						appendDelim = true;
					}

					string propertyName = JsonNameAttribute.GetJsonName(property);
					if (String.IsNullOrEmpty(propertyName))
					{
						propertyName = property.Name;
					}

					this.WriteLine();
					this.Write(propertyName);
					this.writer.Write(JsonReader.OperatorNameDelim);
					this.Write(propertyValue, true);
				}

				// serialize public fields
				FieldInfo[] fields = objType.GetFields();
				foreach (FieldInfo field in fields)
				{
					if (!field.IsPublic || field.IsStatic)
					{
						continue;
					}

					if (this.IsIgnored(objType, field, value))
					{
						continue;
					}

					object fieldValue = field.GetValue(value);
                   
					if (this.IsDefaultValue(field, fieldValue))
					{
						continue;
					}

					if (appendDelim)
					{
						this.writer.Write(JsonReader.OperatorValueDelim);
						this.WriteLine();
					}
					else
					{
						appendDelim = true;
					}

					string fieldName = JsonNameAttribute.GetJsonName(field);
					if (String.IsNullOrEmpty(fieldName))
					{
						fieldName = field.Name;
					}

					// use Attributes here to control naming
					this.Write(fieldName);
					this.writer.Write(JsonReader.OperatorNameDelim);
					this.Write(fieldValue, true);
				}
			}
			finally
			{
				this.depth--;
			}

			if (appendDelim)
			{
				this.WriteLine();
			}
			this.writer.Write(JsonReader.OperatorObjectEnd);
		}

		protected virtual void WriteLine()
		{
			if (!this.prettyPrint)
			{
				return;
			}

			this.writer.WriteLine();
			for (int i=0; i<this.depth; i++)
			{
				this.writer.Write(this.tab);
			}
		}

		#endregion Writer Methods

		#region Private Methods

		/// <summary>
		/// Determines if the property or field should not be serialized.
		/// </summary>
		/// <param name="objType"></param>
		/// <param name="member"></param>
		/// <param name="value"></param>
		/// <returns></returns>
		/// <remarks>
		/// Checks these in order, if any returns true then this is true:
		/// - is flagged with the JsonIgnoreAttribute property
		/// - has a JsonSpecifiedProperty which returns false
		/// </remarks>
		private bool IsIgnored(Type objType, MemberInfo member, object obj)
		{
			if (JsonIgnoreAttribute.IsJsonIgnore(member))
			{
				return true;
			}

			

			if (this.UseXmlSerializationAttributes)
			{
				if (JsonIgnoreAttribute.IsXmlIgnore(member))
				{
					return true;
				}

				PropertyInfo specProp = objType.GetProperty(member.Name+"Specified");
				if (specProp != null)
				{
					object isSpecified = specProp.GetValue(obj, null);
					if (isSpecified is Boolean && !Convert.ToBoolean(isSpecified))
					{
						return true;
					}
				}
			}

			return false;
		}

		/// <summary>
		/// Determines if the member value matches the DefaultValue attribute
		/// </summary>
		/// <returns>if has a value equivalent to the DefaultValueAttribute</returns>
		private bool IsDefaultValue(MemberInfo member, object value)
		{
			DefaultValueAttribute attribute = Attribute.GetCustomAttribute(member, typeof(DefaultValueAttribute)) as DefaultValueAttribute;
			if (attribute == null)
			{
				return false;
			}

			if (attribute.Value == null)
			{
				return (value == null);
			}

			return (attribute.Value.Equals(value));
		}

		#region GetFlagList

		/// <summary>
		/// Splits a bitwise-OR'd set of enums into a list.
		/// </summary>
		/// <param name="enumType">the enum type</param>
		/// <param name="value">the combined value</param>
		/// <returns>list of flag enums</returns>
		/// <remarks>
		/// from PseudoCode.EnumHelper
		/// </remarks>
		private static Enum[] GetFlagList(Type enumType, object value)
		{
			ulong longVal = Convert.ToUInt64(value);
			string[] enumNames = Enum.GetNames(enumType);
			Array enumValues = Enum.GetValues(enumType);

			List<Enum> enums = new List<Enum>(enumValues.Length);

			// check for empty
			if (longVal == 0L)
			{
				// Return the value of empty, or zero if none exists
				if (Convert.ToUInt64(enumValues.GetValue(0)) == 0L)
					enums.Add(enumValues.GetValue(0) as Enum);
				else
					enums.Add(null);
				return enums.ToArray();
			}

			for (int i = enumValues.Length-1; i >= 0; i--)
			{
				ulong enumValue = Convert.ToUInt64(enumValues.GetValue(i));

				if ((i == 0) && (enumValue == 0L))
					continue;

				// matches a value in enumeration
				if ((longVal & enumValue) == enumValue)
				{
					// remove from val
					longVal -= enumValue;

					// add enum to list
					enums.Add(enumValues.GetValue(i) as Enum);
				}
			}

			if (longVal != 0x0L)
				enums.Add(Enum.ToObject(enumType, longVal) as Enum);

			return enums.ToArray();
		}

		#endregion GetFlagList

		#endregion Private Methods

		#region IDisposable Members

		void IDisposable.Dispose()
		{
			if (this.writer != null)
				this.writer.Dispose();
		}

		#endregion IDisposable Members
	}
}