public static JsonData SerializeJson(OSD osd, bool preserveDefaults)
{
switch (osd.Type)
{
case OSDType.Boolean:
return(new JsonData(osd.AsBoolean()));
case OSDType.Integer:
return(new JsonData(osd.AsInteger()));
case OSDType.Real:
return(new JsonData(osd.AsReal()));
case OSDType.String:
case OSDType.Date:
case OSDType.URI:
case OSDType.UUID:
case OSDType.OSDUTF8:
case OSDType.LLSDxml:
return(new JsonData(osd.AsString()));
case OSDType.Binary:
byte[] binary = osd.AsBinary();
JsonData jsonbinarray = new JsonData();
jsonbinarray.SetJsonType(JsonType.Array);
for (int i = 0; i < binary.Length; i++)
{
jsonbinarray.Add(new JsonData(binary[i]));
}
return(jsonbinarray);
case OSDType.Array:
JsonData jsonarray = new JsonData();
jsonarray.SetJsonType(JsonType.Array);
OSDArray array = (OSDArray)osd;
for (int i = 0; i < array.Count; i++)
{
jsonarray.Add(SerializeJson(array[i], preserveDefaults));
}
return(jsonarray);
case OSDType.Map:
JsonData jsonmap = new JsonData();
jsonmap.SetJsonType(JsonType.Object);
OSDMap map = (OSDMap)osd;
foreach (KeyValuePair <string, OSD> kvp in map)
{
JsonData data = preserveDefaults ? SerializeJson(kvp.Value, true) : SerializeJsonNoDefaults(kvp.Value);
if (data != null)
{
jsonmap[kvp.Key] = data;
}
}
return(jsonmap);
case OSDType.Unknown:
default:
return(new JsonData(null));
}
}
public static JsonData SerializeJson(OSD osd)
{
switch (osd.Type)
{
case OSDType.Boolean:
return(new JsonData(osd.AsBoolean()));
case OSDType.Integer:
return(new JsonData(osd.AsInteger()));
case OSDType.Real:
return(new JsonData(osd.AsReal()));
case OSDType.String:
return(new JsonData(osd.AsString()));
case OSDType.Date:
return(new JsonData("date::" + osd.AsString()));
case OSDType.URI:
return(new JsonData("uri::" + osd.AsString()));
case OSDType.UUID:
return(new JsonData("uuid::" + osd.AsString()));
case OSDType.Binary:
return(new JsonData("b64::" + Convert.ToBase64String(osd.AsBinary())));
case OSDType.Array:
JsonData jsonarray = new JsonData();
jsonarray.SetJsonType(JsonType.Array);
OSDArray array = (OSDArray)osd;
for (int i = 0; i < array.Count; i++)
{
jsonarray.Add(SerializeJson(array[i]));
}
return(jsonarray);
case OSDType.Map:
JsonData jsonmap = new JsonData();
jsonmap.SetJsonType(JsonType.Object);
OSDMap map = (OSDMap)osd;
foreach (KeyValuePair <string, OSD> kvp in map)
{
jsonmap[kvp.Key] = SerializeJson(kvp.Value);
}
return(jsonmap);
case OSDType.Unknown:
default:
return(new JsonData());
}
}
public static object ToObject(Type type, OSD value)
{
if (type == typeof(ulong))
{
if (value.Type == OSDType.Binary)
{
byte[] bytes = value.AsBinary();
return(Utils.BytesToUInt64(bytes));
}
else
{
return((ulong)value.AsInteger());
}
}
else if (type == typeof(uint))
{
if (value.Type == OSDType.Binary)
{
byte[] bytes = value.AsBinary();
return(Utils.BytesToUInt(bytes));
}
else
{
return((uint)value.AsInteger());
}
}
else if (type == typeof(ushort))
{
return((ushort)value.AsInteger());
}
else if (type == typeof(byte))
{
return((byte)value.AsInteger());
}
else if (type == typeof(short))
{
return((short)value.AsInteger());
}
else if (type == typeof(string))
{
return(value.AsString());
}
else if (type == typeof(bool))
{
return(value.AsBoolean());
}
else if (type == typeof(float))
{
return((float)value.AsReal());
}
else if (type == typeof(double))
{
return(value.AsReal());
}
else if (type == typeof(int))
{
return(value.AsInteger());
}
else if (type == typeof(UUID))
{
return(value.AsUUID());
}
else if (type == typeof(Vector3))
{
if (value.Type == OSDType.Array)
{
return(((OSDArray)value).AsVector3());
}
else
{
return(Vector3.Zero);
}
}
else if (type == typeof(Vector4))
{
if (value.Type == OSDType.Array)
{
return(((OSDArray)value).AsVector4());
}
else
{
return(Vector4.Zero);
}
}
else if (type == typeof(Quaternion))
{
if (value.Type == OSDType.Array)
{
return(((OSDArray)value).AsQuaternion());
}
else
{
return(Quaternion.Identity);
}
}
else if (type == typeof(OSDArray))
{
OSDArray newArray = new OSDArray();
foreach (OSD o in (OSDArray)value)
{
newArray.Add(o);
}
return(newArray);
}
else if (type == typeof(OSDMap))
{
OSDMap newMap = new OSDMap();
foreach (KeyValuePair <string, OSD> o in (OSDMap)value)
{
newMap.Add(o);
}
return(newMap);
}
else
{
return(null);
}
}
public static object ToObject(Type type, OSD value)
{
if (type == typeof(ulong))
{
if (value.Type == OSDType.Binary)
{
byte[] bytes = value.AsBinary();
return(Utils.BytesToUInt64(bytes));
}
else
{
return((ulong)value.AsInteger());
}
}
else if (type == typeof(uint))
{
if (value.Type == OSDType.Binary)
{
byte[] bytes = value.AsBinary();
return(Utils.BytesToUInt(bytes));
}
else
{
return((uint)value.AsInteger());
}
}
else if (type == typeof(ushort))
{
return((ushort)value.AsInteger());
}
else if (type == typeof(byte))
{
return((byte)value.AsInteger());
}
else if (type == typeof(short))
{
return((short)value.AsInteger());
}
else if (type == typeof(string))
{
return(value.AsString());
}
else if (type == typeof(bool))
{
return(value.AsBoolean());
}
else if (type == typeof(float))
{
return((float)value.AsReal());
}
else if (type == typeof(double))
{
return(value.AsReal());
}
else if (type == typeof(int))
{
return(value.AsInteger());
}
else if (type == typeof(UUID))
{
return(value.AsUUID());
}
else if (type == typeof(Vector3))
{
if (value.Type == OSDType.Array)
{
return(((OSDArray)value).AsVector3());
}
else
{
return(Vector3.Zero);
}
}
else if (type == typeof(Vector4))
{
if (value.Type == OSDType.Array)
{
return(((OSDArray)value).AsVector4());
}
else
{
return(Vector4.Zero);
}
}
else if (type == typeof(Quaternion))
{
if (value.Type == OSDType.Array)
{
return(((OSDArray)value).AsQuaternion());
}
else
{
return(Quaternion.Identity);
}
}
else
{
return(null);
}
}
private static JsonData SerializeJsonNoDefaults(OSD osd)
{
switch (osd.Type)
{
case OSDType.Boolean:
bool b = osd.AsBoolean();
if (!b)
{
return(null);
}
return(new JsonData(b));
case OSDType.Integer:
int v = osd.AsInteger();
if (v == 0)
{
return(null);
}
return(new JsonData(v));
case OSDType.Real:
double d = osd.AsReal();
if (d == 0.0d)
{
return(null);
}
return(new JsonData(d));
case OSDType.String:
case OSDType.Date:
case OSDType.URI:
string str = osd.AsString();
if (String.IsNullOrEmpty(str))
{
return(null);
}
return(new JsonData(str));
case OSDType.UUID:
UUID uuid = osd.AsUUID();
if (uuid == UUID.Zero)
{
return(null);
}
return(new JsonData(uuid.ToString()));
case OSDType.Binary:
byte[] binary = osd.AsBinary();
if (binary == Utils.EmptyBytes)
{
return(null);
}
JsonData jsonbinarray = new JsonData();
jsonbinarray.SetJsonType(JsonType.Array);
for (int i = 0; i < binary.Length; i++)
{
jsonbinarray.Add(new JsonData(binary[i]));
}
return(jsonbinarray);
case OSDType.Array:
JsonData jsonarray = new JsonData();
jsonarray.SetJsonType(JsonType.Array);
OSDArray array = (OSDArray)osd;
for (int i = 0; i < array.Count; i++)
{
jsonarray.Add(SerializeJson(array[i], false));
}
return(jsonarray);
case OSDType.Map:
JsonData jsonmap = new JsonData();
jsonmap.SetJsonType(JsonType.Object);
OSDMap map = (OSDMap)osd;
foreach (KeyValuePair <string, OSD> kvp in map)
{
JsonData data = SerializeJsonNoDefaults(kvp.Value);
if (data != null)
{
jsonmap[kvp.Key] = data;
}
}
return(jsonmap);
case OSDType.Unknown:
default:
return(null);
}
}
public static JsonData SerializeJson(OSD osd, bool preserveDefaults)
{
switch (osd.Type)
{
case OSDType.Boolean:
return(new JsonData(osd.AsBoolean()));
case OSDType.Integer:
return(new JsonData(osd.AsInteger()));
case OSDType.Real:
return(new JsonData(osd.AsReal()));
case OSDType.String:
case OSDType.Date:
case OSDType.URI:
case OSDType.UUID:
return(new JsonData(osd.AsString()));
case OSDType.Binary:
byte[] binary = osd.AsBinary();
JsonData jsonbinarray = new JsonData();
jsonbinarray.SetJsonType(JsonType.Array);
foreach (byte t in binary)
{
jsonbinarray.Add(new JsonData(t));
}
return(jsonbinarray);
case OSDType.Array:
JsonData jsonarray = new JsonData();
jsonarray.SetJsonType(JsonType.Array);
OSDArray array = (OSDArray)osd;
foreach (OSD t in array)
{
jsonarray.Add(SerializeJson(t, preserveDefaults));
}
return(jsonarray);
case OSDType.Map:
JsonData jsonmap = new JsonData();
jsonmap.SetJsonType(JsonType.Object);
OSDMap map = (OSDMap)osd;
foreach (KeyValuePair <string, OSD> kvp in map)
{
var data = preserveDefaults
? SerializeJson(kvp.Value, preserveDefaults)
: SerializeJsonNoDefaults(kvp.Value);
if (data != null)
{
jsonmap[kvp.Key] = data;
}
}
return(jsonmap);
case OSDType.Unknown:
default:
return(new JsonData(null));
}
}
private static void SerializeLLSDNotationElement(TextWriter writer, OSD osd)
{
switch (osd.Type)
{
case OSDType.Unknown:
writer.Write(undefNotationValue);
break;
case OSDType.Boolean:
if (osd.AsBoolean())
{
writer.Write(trueNotationValueTwo);
}
else
{
writer.Write(falseNotationValueTwo);
}
break;
case OSDType.Integer:
writer.Write(integerNotationMarker);
writer.Write(osd.AsString());
break;
case OSDType.Real:
writer.Write(realNotationMarker);
writer.Write(osd.AsString());
break;
case OSDType.UUID:
writer.Write(uuidNotationMarker);
writer.Write(osd.AsString());
break;
case OSDType.String:
writer.Write(singleQuotesNotationMarker);
EscapeCharacter(osd.AsString(), singleQuotesNotationMarker, writer);
writer.Write(singleQuotesNotationMarker);
break;
case OSDType.Binary:
writer.Write(binaryNotationMarker);
writer.Write("64");
writer.Write(doubleQuotesNotationMarker);
base64Encode(osd.AsBinary(), writer);
writer.Write(doubleQuotesNotationMarker);
break;
case OSDType.Date:
writer.Write(dateNotationMarker);
writer.Write(doubleQuotesNotationMarker);
writer.Write(osd.AsString());
writer.Write(doubleQuotesNotationMarker);
break;
case OSDType.URI:
writer.Write(uriNotationMarker);
writer.Write(doubleQuotesNotationMarker);
writer.Write(osd.AsString());
writer.Write(doubleQuotesNotationMarker);
break;
case OSDType.Array:
SerializeLLSDNotationArray(writer, (OSDArray)osd);
break;
case OSDType.Map:
SerializeLLSDNotationMap(writer, (OSDMap)osd);
break;
default:
throw new OSDException("Notation serialization: Not existing element discovered.");
}
}
public static void SerializeLLSDXmlElement(osUTF8 mb, OSD data, bool formal)
{
switch (data.Type)
{
case OSDType.Unknown:
mb.Append(osUTF8Const.XMLundef);
break;
case OSDType.Boolean:
if (data.AsBoolean())
{
mb.Append(osUTF8Const.XMLfullbooleanOne);
}
else
{
mb.Append(osUTF8Const.XMLfullbooleanZero);
}
break;
case OSDType.Integer:
mb.Append(osUTF8Const.XMLintegerStart);
mb.AppendInt(data.AsInteger());
mb.Append(osUTF8Const.XMLintegerEnd);
break;
case OSDType.Real:
mb.Append(osUTF8Const.XMLrealStart);
mb.AppendASCII(data.ToString());
mb.Append(osUTF8Const.XMLrealEnd);
break;
case OSDType.String:
mb.Append(osUTF8Const.XMLstringStart);
EscapeToXML(mb, data);
mb.Append(osUTF8Const.XMLstringEnd);
break;
case OSDType.UUID:
mb.Append(osUTF8Const.XMLuuidStart);
mb.AppendUUID(data.AsUUID());
mb.Append(osUTF8Const.XMLuuidEnd);
break;
case OSDType.Date:
mb.Append(osUTF8Const.XMLdateStart);
mb.AppendASCII(data.ToString());
mb.Append(osUTF8Const.XMLdateEnd);
break;
case OSDType.URI:
mb.Append(osUTF8Const.XMLuriStart);
EscapeToXML(mb, data.ToString());
mb.Append(osUTF8Const.XMLuriEnd);
break;
case OSDType.Binary:
if (formal)
{
mb.Append(osUTF8Const.XMLformalBinaryStart);
}
else
{
mb.Append(osUTF8Const.XMLbinaryStart);
}
base64Encode(data.AsBinary(), mb);
mb.Append(osUTF8Const.XMLbinaryEnd);
break;
case OSDType.Map:
mb.Append(osUTF8Const.XMLmapStart);
foreach (KeyValuePair <string, OSD> kvp in (OSDMap)data)
{
mb.Append(osUTF8Const.XMLkeyStart);
mb.Append(kvp.Key.ToString());
mb.Append(osUTF8Const.XMLkeyEnd);
SerializeLLSDXmlElement(mb, kvp.Value, formal);
}
mb.Append(osUTF8Const.XMLmapEnd);
break;
case OSDType.Array:
OSDArray array = (OSDArray)data;
mb.Append(osUTF8Const.XMLarrayStart);
for (int i = 0; i < array.Count; i++)
{
SerializeLLSDXmlElement(mb, array[i], formal);
}
mb.Append(osUTF8Const.XMLarrayEnd);
break;
case OSDType.LLSDxml:
mb.Append(data.AsString());
break;
default:
break;
}
}
/// <summary>
///
/// </summary>
/// <param name="writer"></param>
/// <param name="data"></param>
public static void SerializeLLSDXmlElement(StringBuilder sb, OSD data, bool formal)
{
switch (data.Type)
{
case OSDType.Unknown:
sb.Append("<undef />");
break;
case OSDType.Boolean:
if (data.AsBoolean())
{
sb.Append("<boolean>1</boolean>");
}
else
{
sb.Append("<boolean>0</boolean>");
}
break;
case OSDType.Integer:
sb.Append("<integer>");
sb.Append(data.AsString());
sb.Append("</integer>");
break;
case OSDType.Real:
sb.Append("<real>");
sb.Append(data.AsString());
sb.Append("</real>");
break;
case OSDType.String:
sb.Append("<string>");
EscapeToXML(data.AsString(), sb);
sb.Append("</string>");
break;
case OSDType.UUID:
sb.Append("<uuid>");
sb.Append(data.AsString());
sb.Append("</uuid>");
break;
case OSDType.Date:
sb.Append("<date>");
sb.Append(data.AsString());
sb.Append("</date>");
break;
case OSDType.URI:
sb.Append("<uri>");
sb.Append(data.AsString());
sb.Append("</uri>");
break;
case OSDType.Binary:
if (formal)
{
sb.Append("<binary encoding=\"base64\">");
}
else
{
sb.Append("<binary>");
}
base64Encode(data.AsBinary(), sb);
sb.Append("</binary>");
break;
case OSDType.Map:
OSDMap map = (OSDMap)data;
sb.Append("<map>");
foreach (KeyValuePair <string, OSD> kvp in map)
{
sb.Append("<key>");
sb.Append(kvp.Key);
sb.Append("</key>");
SerializeLLSDXmlElement(sb, kvp.Value, formal);
}
sb.Append("</map>");
break;
case OSDType.Array:
OSDArray array = (OSDArray)data;
sb.Append("<array>");
for (int i = 0; i < array.Count; i++)
{
SerializeLLSDXmlElement(sb, array[i], formal);
}
sb.Append("</array>");
break;
case OSDType.LLSDxml:
sb.Append(data.AsString());
break;
default:
break;
}
}
private static void SerializeLLSDBinaryElement(MemoryStream stream, OSD osd)
{
switch (osd.Type)
{
case OSDType.Unknown:
stream.WriteByte(undefBinaryValue);
break;
case OSDType.Boolean:
stream.Write(osd.AsBinary(), 0, 1);
break;
case OSDType.Integer:
stream.WriteByte(integerBinaryMarker);
stream.Write(osd.AsBinary(), 0, int32Length);
break;
case OSDType.Real:
stream.WriteByte(realBinaryMarker);
stream.Write(osd.AsBinary(), 0, doubleLength);
break;
case OSDType.UUID:
stream.WriteByte(uuidBinaryMarker);
stream.Write(osd.AsBinary(), 0, 16);
break;
case OSDType.String:
stream.WriteByte(stringBinaryMarker);
byte[] rawString = osd.AsBinary();
byte[] stringLengthNetEnd = Utils.IntToBytesBig(rawString.Length);
stream.Write(stringLengthNetEnd, 0, int32Length);
stream.Write(rawString, 0, rawString.Length);
break;
case OSDType.Binary:
stream.WriteByte(binaryBinaryMarker);
byte[] rawBinary = osd.AsBinary();
byte[] binaryLengthNetEnd = Utils.IntToBytesBig(rawBinary.Length);
stream.Write(binaryLengthNetEnd, 0, int32Length);
stream.Write(rawBinary, 0, rawBinary.Length);
break;
case OSDType.Date:
stream.WriteByte(dateBinaryMarker);
stream.Write(osd.AsBinary(), 0, doubleLength);
break;
case OSDType.URI:
stream.WriteByte(uriBinaryMarker);
byte[] rawURI = osd.AsBinary();
byte[] uriLengthNetEnd = Utils.IntToBytesBig(rawURI.Length);
stream.Write(uriLengthNetEnd, 0, int32Length);
stream.Write(rawURI, 0, rawURI.Length);
break;
case OSDType.Array:
SerializeLLSDBinaryArray(stream, (OSDArray)osd);
break;
case OSDType.Map:
SerializeLLSDBinaryMap(stream, (OSDMap)osd);
break;
default:
throw new OSDException("Binary serialization: Not existing element discovered.");
}
}
public static void SerializeJsonMapNoDefaults(string name, OSD osd, ref int mapcont, osUTF8 sb)
{
int i;
switch (osd.Type)
{
case OSDType.Boolean:
bool ob = osd.AsBoolean();
if (ob)
{
if (mapcont++ > 0)
{
sb.AppendASCII(',');
}
appendJsonString(name, sb);
sb.AppendASCII(':');
sb.Append(ob ? osUTF8Const.OSUTF8true : osUTF8Const.OSUTF8false);
}
break;
case OSDType.Integer:
int oi = osd.AsInteger();
if (oi != 0)
{
if (mapcont++ > 0)
{
sb.AppendASCII(',');
}
appendJsonString(name, sb);
sb.AppendASCII(':');
sb.AppendInt(oi);
}
break;
case OSDType.Real:
double od = osd.AsReal();
if (od != 0)
{
if (mapcont++ > 0)
{
sb.AppendASCII(',');
}
appendJsonString(name, sb);
sb.AppendASCII(':');
string str = Convert.ToString(od, NumberFormatInfo.InvariantInfo);
sb.AppendASCII(str);
if (str.IndexOfAny(new char[] { '.', 'E' }) == -1)
{
sb.AppendASCII(".0");
}
}
break;
case OSDType.String:
case OSDType.URI:
case OSDType.LLSDxml:
string ostr = osd.AsString();
if (!string.IsNullOrEmpty(ostr))
{
if (mapcont++ > 0)
{
sb.AppendASCII(',');
}
appendJsonString(name, sb);
sb.AppendASCII(':');
appendJsonString(ostr, sb);
}
break;
case OSDType.OSDUTF8:
osUTF8 ou8 = ((OSDUTF8)osd).value;
if (ou8 != null && ou8.Length > 0)
{
if (mapcont++ > 0)
{
sb.AppendASCII(',');
}
appendJsonString(name, sb);
sb.AppendASCII(':');
appendJsonOSUTF8(ou8, sb);
}
break;
case OSDType.UUID:
UUID ou = osd.AsUUID();
if (ou.IsNotZero())
{
if (mapcont++ > 0)
{
sb.AppendASCII(',');
}
appendJsonString(name, sb);
sb.AppendASCII(":\"");
sb.AppendUUID(ou);
sb.AppendASCII('"');
}
break;
case OSDType.Date:
if (mapcont++ > 0)
{
sb.AppendASCII(',');
}
appendJsonString(name, sb);
sb.AppendASCII(':');
appendJsonString(osd.AsString(), sb);
break;
case OSDType.Binary:
byte[] binary = osd.AsBinary();
if (mapcont++ > 0)
{
sb.AppendASCII(',');
}
appendJsonString(name, sb);
sb.AppendASCII(":[");
if (binary != null && binary.Length > 0)
{
i = 0;
while (i < binary.Length - 1)
{
sb.AppendInt(binary[i++]);
sb.AppendASCII(',');
}
if (i < binary.Length)
{
sb.AppendInt(binary[i]);
}
}
sb.AppendASCII(']');
break;
case OSDType.Array:
if (mapcont++ > 0)
{
sb.AppendASCII(",");
}
appendJsonString(name, sb);
sb.AppendASCII(":[");
OSDArray array = (OSDArray)osd;
if (array != null && array.Count > 0)
{
i = 0;
while (i < array.Count - 1)
{
SerializeJson(array[i++], sb, false);
sb.AppendASCII(',');
}
if (i < array.Count)
{
SerializeJson(array[i], sb, false);
}
}
sb.AppendASCII(']');
break;
case OSDType.Map:
OSDMap map = (OSDMap)osd;
if (map != null && map.Count > 0)
{
if (mapcont++ > 0)
{
sb.AppendASCII(',');
}
appendJsonString(name, sb);
sb.AppendASCII(":{");
i = 0;
foreach (KeyValuePair <string, OSD> kvp in map)
{
SerializeJsonMapNoDefaults(kvp.Key, kvp.Value, ref i, sb);
}
sb.AppendASCII('}');
}
break;
case OSDType.Unknown:
default:
break;
}
}
public static void SerializeJson(OSD osd, osUTF8 sb, bool preserveDefaults)
{
int i;
switch (osd.Type)
{
case OSDType.Boolean:
sb.Append(osd.AsBoolean() ? osUTF8Const.OSUTF8true : osUTF8Const.OSUTF8false);
break;
case OSDType.Integer:
sb.AppendInt(osd.AsInteger());
break;
case OSDType.Real:
string str = Convert.ToString(osd.AsReal(), NumberFormatInfo.InvariantInfo);
sb.AppendASCII(str);
if (str.IndexOfAny(new char[] { '.', 'E' }) == -1)
{
sb.AppendASCII(".0");
}
break;
case OSDType.String:
case OSDType.URI:
case OSDType.LLSDxml:
appendJsonString(osd.AsString(), sb);
break;
case OSDType.OSDUTF8:
osUTF8 ou8 = ((OSDUTF8)osd).value;
appendJsonOSUTF8(ou8, sb);
break;
case OSDType.UUID:
sb.AppendASCII('"');
sb.AppendUUID(osd.AsUUID());
sb.AppendASCII('"');
break;
case OSDType.Date:
appendJsonString(osd.AsString(), sb);
break;
case OSDType.Binary:
byte[] binary = osd.AsBinary();
i = 0;
sb.AppendASCII('[');
while (i < binary.Length - 1)
{
sb.AppendInt(binary[i++]);
sb.AppendASCII(',');
}
if (i < binary.Length)
{
sb.AppendInt(binary[i]);
}
sb.AppendASCII(']');
break;
case OSDType.Array:
sb.AppendASCII('[');
OSDArray array = (OSDArray)osd;
i = 0;
while (i < array.Count - 1)
{
SerializeJson(array[i++], sb, preserveDefaults);
sb.AppendASCII(',');
}
if (i < array.Count)
{
SerializeJson(array[i], sb, preserveDefaults);
}
sb.AppendASCII(']');
break;
case OSDType.Map:
sb.AppendASCII('{');
OSDMap map = (OSDMap)osd;
i = 0;
foreach (KeyValuePair <string, OSD> kvp in map)
{
if (preserveDefaults)
{
if (i++ > 0)
{
sb.AppendASCII(',');
}
appendJsonString(kvp.Key, sb);
sb.AppendASCII(':');
SerializeJson(kvp.Value, sb, true);
}
else
{
SerializeJsonMapNoDefaults(kvp.Key, kvp.Value, ref i, sb);
}
}
sb.AppendASCII('}');
break;
case OSDType.Unknown:
default:
sb.Append(osUTF8Const.OSUTF8null);
break;
}
}
