/// <summary> /// Fire the events registered for this event type asynchronously /// </summary> /// <param name="capsEvent">Capability name</param> /// <param name="body">Decoded event body</param> /// <param name="simulator">Reference to the simulator that /// generated this event</param> internal void BeginRaiseEvent(string capsEvent, StructuredData.LLSD body, Simulator simulator) { bool specialHandler = false; Caps.EventQueueCallback callback; // Default handler first, if one exists if (_EventTable.TryGetValue(String.Empty, out callback)) { if (callback != null) { CapsCallbackWrapper wrapper; wrapper.Callback = callback; wrapper.CapsEvent = capsEvent; wrapper.Body = body; wrapper.Simulator = simulator; ThreadPool.QueueUserWorkItem(_ThreadPoolCallback, wrapper); } } // Generic parser next, don't generic parse events we've manually registered for if (body.Type == StructuredData.LLSDType.Map && !_EventTable.ContainsKey(capsEvent)) { StructuredData.LLSDMap map = (StructuredData.LLSDMap)body; Packet packet = Packet.BuildPacket(capsEvent, map); if (packet != null) { NetworkManager.IncomingPacket incomingPacket; incomingPacket.Simulator = simulator; incomingPacket.Packet = packet; Logger.DebugLog("Serializing " + packet.Type.ToString() + " capability with generic handler", Client); Client.Network.PacketInbox.Enqueue(incomingPacket); specialHandler = true; } } // Explicit handler next if (_EventTable.TryGetValue(capsEvent, out callback) && callback != null) { CapsCallbackWrapper wrapper; wrapper.Callback = callback; wrapper.CapsEvent = capsEvent; wrapper.Body = body; wrapper.Simulator = simulator; ThreadPool.QueueUserWorkItem(_ThreadPoolCallback, wrapper); specialHandler = true; } if (!specialHandler) Logger.Log("Unhandled CAPS event " + capsEvent, Helpers.LogLevel.Warning, Client); }
private static LLSDMap ParseXmlMap(XmlTextReader reader) { if (reader.NodeType != XmlNodeType.Element || reader.LocalName != "map") { throw new NotImplementedException("Expected <map>"); } LLSDMap map = new LLSDMap(); if (reader.IsEmptyElement) { reader.Read(); return(map); } if (reader.Read()) { while (true) { SkipWhitespace(reader); if (reader.NodeType == XmlNodeType.EndElement && reader.LocalName == "map") { reader.Read(); break; } if (reader.NodeType != XmlNodeType.Element || reader.LocalName != "key") { throw new LLSDException("Expected <key>"); } string key = reader.ReadString(); if (reader.NodeType != XmlNodeType.EndElement || reader.LocalName != "key") { throw new LLSDException("Expected </key>"); } if (reader.Read()) { map[key] = ParseXmlElement(reader); } else { throw new LLSDException("Failed to parse a value for key " + key); } } } return(map); }
private static LLSD DeserializeNotationMap(StringReader reader) { int character; LLSDMap llsdMap = new LLSDMap(); while (((character = PeekAndSkipWhitespace(reader)) > 0) && ((char)character != mapEndNotationMarker)) { LLSD llsdKey = DeserializeNotationElement(reader); if (llsdKey.Type != LLSDType.String) { throw new LLSDException("Notation LLSD parsing: Invalid key in map"); } string key = llsdKey.AsString(); character = ReadAndSkipWhitespace(reader); if ((char)character != keyNotationDelimiter) { throw new LLSDException("Notation LLSD parsing: Unexpected end of stream in map."); } if ((char)character != keyNotationDelimiter) { throw new LLSDException("Notation LLSD parsing: Invalid delimiter in map."); } llsdMap[key] = DeserializeNotationElement(reader); character = ReadAndSkipWhitespace(reader); if (character < 0) { throw new LLSDException("Notation LLSD parsing: Unexpected end of map discovered."); } else if ((char)character == kommaNotationDelimiter) { continue; } else if ((char)character == mapEndNotationMarker) { break; } } if (character < 0) { throw new LLSDException("Notation LLSD parsing: Unexpected end of map discovered."); } return((LLSD)llsdMap); }
private static void SerializeBinaryMap(MemoryStream stream, LLSDMap llsdMap) { stream.WriteByte(mapBeginBinaryMarker); byte[] binaryNumElementsNetEnd = HostToNetworkIntBytes(llsdMap.Count); stream.Write(binaryNumElementsNetEnd, 0, int32Length); foreach (KeyValuePair <string, LLSD> kvp in llsdMap) { stream.WriteByte(keyBinaryMarker); byte[] binaryKey = Encoding.UTF8.GetBytes(kvp.Key); byte[] binaryKeyLength = HostToNetworkIntBytes(binaryKey.Length); stream.Write(binaryKeyLength, 0, int32Length); stream.Write(binaryKey, 0, binaryKey.Length); SerializeBinaryElement(stream, kvp.Value); } stream.WriteByte(mapEndBinaryMarker); }
/// <summary> /// Fire the events registered for this event type synchronously /// </summary> /// <param name="capsEvent">Capability name</param> /// <param name="body">Decoded event body</param> /// <param name="simulator">Reference to the simulator that /// generated this event</param> internal void RaiseEvent(string capsEvent, StructuredData.LLSD body, Simulator simulator) { bool specialHandler = false; Caps.EventQueueCallback callback; // Default handler first, if one exists if (_EventTable.TryGetValue(capsEvent, out callback)) { if (callback != null) { try { callback(capsEvent, body, simulator); } catch (Exception ex) { Logger.Log("CAPS Event Handler: " + ex.ToString(), Helpers.LogLevel.Error, Client); } } } // Generic parser next if (body.Type == StructuredData.LLSDType.Map) { StructuredData.LLSDMap map = (StructuredData.LLSDMap)body; Packet packet = Packet.BuildPacket(capsEvent, map); if (packet != null) { NetworkManager.IncomingPacket incomingPacket; incomingPacket.Simulator = simulator; incomingPacket.Packet = packet; Logger.DebugLog("Serializing " + packet.Type.ToString() + " capability with generic handler", Client); Client.Network.PacketInbox.Enqueue(incomingPacket); specialHandler = true; } } // Explicit handler next if (_EventTable.TryGetValue(capsEvent, out callback) && callback != null) { try { callback(capsEvent, body, simulator); } catch (Exception ex) { Logger.Log("CAPS Event Handler: " + ex.ToString(), Helpers.LogLevel.Error, Client); } specialHandler = true; } if (!specialHandler) Logger.Log("Unhandled CAPS event " + capsEvent, Helpers.LogLevel.Warning, Client); }
/// <summary> /// Deserializes LLSD in to a list of primitives /// </summary> /// <param name="llsd">Structure holding the serialized primitive list, /// must be of the LLSDMap type</param> /// <returns>A list of deserialized primitives</returns> public static List <Primitive> LLSDToPrimList(StructuredData.LLSD llsd) { if (llsd.Type != StructuredData.LLSDType.Map) { throw new ArgumentException("LLSD must be in the Map structure"); } StructuredData.LLSDMap map = (StructuredData.LLSDMap)llsd; List <Primitive> prims = new List <Primitive>(map.Count); foreach (KeyValuePair <string, StructuredData.LLSD> kvp in map) { Primitive prim = Primitive.FromLLSD(kvp.Value); prim.LocalID = UInt32.Parse(kvp.Key); prims.Add(prim); } return(prims); }
/// <summary> /// Uses reflection to deserialize member variables in an object from /// an LLSDMap /// </summary> /// <param name="obj">Reference to an object to fill with deserialized /// values</param> /// <param name="serialized">Serialized values to put in the target /// object</param> public static void DeserializeMembers(ref object obj, LLSDMap serialized) { Type t = obj.GetType(); FieldInfo[] fields = t.GetFields(); for (int i = 0; i < fields.Length; i++) { FieldInfo field = fields[i]; if (!Attribute.IsDefined(field, typeof(NonSerializedAttribute))) { LLSD serializedField; if (serialized.TryGetValue(field.Name, out serializedField)) { field.SetValue(obj, ToObject(field.FieldType, serializedField)); } } } }
private static void SerializeNotationMap(StringWriter writer, LLSDMap llsdMap) { writer.Write(mapBeginNotationMarker); int lastIndex = llsdMap.Count - 1; int idx = 0; foreach (KeyValuePair <string, LLSD> kvp in llsdMap) { writer.Write(singleQuotesNotationMarker); writer.Write(EscapeCharacter(kvp.Key, singleQuotesNotationMarker)); writer.Write(singleQuotesNotationMarker); writer.Write(keyNotationDelimiter); SerializeNotationElement(writer, kvp.Value); if (idx < lastIndex) { writer.Write(kommaNotationDelimiter); } idx++; } writer.Write(mapEndNotationMarker); }
/// <summary> /// Uses reflection to create an LLSDMap from all of the LLSD /// serializable types in an object /// </summary> /// <param name="obj">Class or struct containing serializable types</param> /// <returns>An LLSDMap holding the serialized values from the /// container object</returns> public static LLSDMap SerializeMembers(object obj) { Type t = obj.GetType(); FieldInfo[] fields = t.GetFields(); LLSDMap map = new LLSDMap(fields.Length); for (int i = 0; i < fields.Length; i++) { FieldInfo field = fields[i]; if (!Attribute.IsDefined(field, typeof(NonSerializedAttribute))) { LLSD serializedField = LLSD.FromObject(field.GetValue(obj)); if (serializedField.Type != LLSDType.Unknown || field.FieldType == typeof(string) || field.FieldType == typeof(byte[])) { map.Add(field.Name, serializedField); } } } return(map); }
private static void SerializeNotationMapFormatted(StringWriter writer, string intend, LLSDMap llsdMap) { writer.Write(Helpers.NewLine); writer.Write(intend); writer.Write(mapBeginNotationMarker); writer.Write(Helpers.NewLine); int lastIndex = llsdMap.Count - 1; int idx = 0; foreach (KeyValuePair <string, LLSD> kvp in llsdMap) { writer.Write(intend + baseIndent); writer.Write(singleQuotesNotationMarker); writer.Write(EscapeCharacter(kvp.Key, singleQuotesNotationMarker)); writer.Write(singleQuotesNotationMarker); writer.Write(keyNotationDelimiter); SerializeNotationElementFormatted(writer, intend, kvp.Value); if (idx < lastIndex) { writer.Write(Helpers.NewLine); writer.Write(intend + baseIndent); writer.Write(kommaNotationDelimiter); writer.Write(Helpers.NewLine); } idx++; } writer.Write(Helpers.NewLine); writer.Write(intend); writer.Write(mapEndNotationMarker); }
/// <summary> /// /// </summary> /// <param name="writer"></param> /// <param name="data"></param> public static void SerializeXmlElement(XmlTextWriter writer, LLSD data) { switch (data.Type) { case LLSDType.Unknown: writer.WriteStartElement(String.Empty, "undef", String.Empty); writer.WriteEndElement(); break; case LLSDType.Boolean: writer.WriteStartElement(String.Empty, "boolean", String.Empty); writer.WriteString(data.AsString()); writer.WriteEndElement(); break; case LLSDType.Integer: writer.WriteStartElement(String.Empty, "integer", String.Empty); writer.WriteString(data.AsString()); writer.WriteEndElement(); break; case LLSDType.Real: writer.WriteStartElement(String.Empty, "real", String.Empty); writer.WriteString(data.AsString()); writer.WriteEndElement(); break; case LLSDType.String: writer.WriteStartElement(String.Empty, "string", String.Empty); writer.WriteString(data.AsString()); writer.WriteEndElement(); break; case LLSDType.UUID: writer.WriteStartElement(String.Empty, "uuid", String.Empty); writer.WriteString(data.AsString()); writer.WriteEndElement(); break; case LLSDType.Date: writer.WriteStartElement(String.Empty, "date", String.Empty); writer.WriteString(data.AsString()); writer.WriteEndElement(); break; case LLSDType.URI: writer.WriteStartElement(String.Empty, "uri", String.Empty); writer.WriteString(data.AsString()); writer.WriteEndElement(); break; case LLSDType.Binary: writer.WriteStartElement(String.Empty, "binary", String.Empty); writer.WriteStartAttribute(String.Empty, "encoding", String.Empty); writer.WriteString("base64"); writer.WriteEndAttribute(); writer.WriteString(data.AsString()); writer.WriteEndElement(); break; case LLSDType.Map: LLSDMap map = (LLSDMap)data; writer.WriteStartElement(String.Empty, "map", String.Empty); foreach (KeyValuePair <string, LLSD> kvp in map) { writer.WriteStartElement(String.Empty, "key", String.Empty); writer.WriteString(kvp.Key); writer.WriteEndElement(); SerializeXmlElement(writer, kvp.Value); } writer.WriteEndElement(); break; case LLSDType.Array: LLSDArray array = (LLSDArray)data; writer.WriteStartElement(String.Empty, "array", String.Empty); for (int i = 0; i < array.Count; i++) { SerializeXmlElement(writer, array[i]); } writer.WriteEndElement(); break; } }