/// <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;
}
}
