public void WriteObject(Amf3Writer writer, object obj)
{
if (obj.GetType() != mType)
{
throw new Exception("Serializer type mismatch");
}
// begin write
writer.WriteObjectHeader(mClassDef);
// write all fields using reflection
foreach (var field in mFieldList)
{
// get field value and write it
object value = field.GetValue(obj);
writer.Write(value);
}
// read all properties using reflection
foreach (var property in mPropertyList)
{
// get property value and write it
object value = property.GetValue(obj, null);
writer.Write(value);
}
}
public int delta; // time since last span (in microseconds)
#region IAmf3Serializable implementation
public void Serialize(Amf3Writer writer)
{
writer.WriteObjectHeader(ClassDef);
writer.Write(name);
writer.Write(span);
writer.Write(delta);
}
public void Serialize(Amf3Writer writer)
{
writer.WriteObjectHeader(ClassDef, this);
// write class properties
for (int i = 0; i < Values.Length; i++)
{
writer.Write(Values[i]);
}
if (ClassDef.Dynamic)
{
// write dynamic properties
// TODO: this is a little weird and shouldnt be here.. should be handled by the writer
foreach (var kvp in DynamicProperties)
{
writer.TypelessWrite(kvp.Key);
writer.Write(kvp.Value);
}
// write terminator
writer.TypelessWrite("");
}
}
// this function parses json text, generates class definitions, and writes object graph to output stream
public static void JsonStringToAmfStream(string jsonText, Stream outStream, bool generateClassDefinitions)
{
// parse json
object jsonRoot = _root.JSON.parse(jsonText);
// generate class definitions (optionally)
if (generateClassDefinitions)
{
GenerateAndApplyClassDefinitions(jsonRoot);
}
// write to amf stream
var amfWriter = new Amf3Writer(outStream);
amfWriter.Write(jsonRoot);
}
public void WriteObject(Amf3Writer writer, object obj)
{
var expando = (ExpandoObject)obj;
writer.Write(expando);
}
void IAmf3Serializable.Serialize(Amf3Writer writer)
{
writer.Write(this);
}
public void Serialize(Amf3Writer writer)
{
writer.Write(this);
}
public void Serialize(Amf3Writer writer)
{
writer.WriteObjectHeader(ClassDef);
writer.Write(name);
writer.Write(value);
}
public void Serialize(Amf3Writer writer)
{
writer.WriteObjectHeader(ClassDef);
writer.Write(time);
writer.Write(numticks);
writer.Write(ticktimes);
writer.Write(callstack);
}
public void Serialize(Amf3Writer writer)
{
writer.WriteObjectHeader(ClassDef);
writer.Write(time);
writer.Write(id);
}
public void Serialize(Amf3Writer writer)
{
writer.WriteObjectHeader(ClassDef);
writer.Write(xmin);
writer.Write(xmax);
writer.Write(ymin);
writer.Write(ymax);
writer.Write(name);
writer.Write(symbolname);
writer.Write(modified);
}
public void Serialize(Amf3Writer writer)
{
writer.WriteObjectHeader(ClassDef);
writer.Write(xmin);
writer.Write(xmax);
writer.Write(ymin);
writer.Write(ymax);
}
public void Serialize(Amf3Writer writer)
{
writer.Write(this);
}
private static void WriteLogEntry(ref LogEntry entry, ref int timeBase, Amf3Writer output)
{
if (entry.Span == LogValue) {
// emit Value
output.WriteObjectHeader(Protocol.Value.ClassDef);
output.Write(entry.Name);
output.Write(entry.Value);
} else if (entry.Span == LogTime) {
// emit Time
int time = ToMicroSeconds(entry.Time);
int delta = time - timeBase;
timeBase = time;
output.WriteObjectHeader(Protocol.Time.ClassDef);
output.Write(entry.Name);
output.Write(delta);
} else {
// emit Span or SpanValue
// convert times to microseconds for output
int time = ToMicroSeconds(entry.Time);
int beginTime = ToMicroSeconds(entry.Time - entry.Span);
// compute span and delta in microseconds
// this must be done this exact way to preserve rounding errors across spans
// if not, the server may produce an error if a span exceeds its expected length
int span = time - beginTime;
int delta = time - timeBase;
timeBase = time;
if (entry.Value == null) {
output.WriteObjectHeader(Protocol.Span.ClassDef);
output.Write(entry.Name);
output.Write(span);
output.Write(delta);
} else {
output.WriteObjectHeader(Protocol.SpanValue.ClassDef);
output.Write(entry.Name);
output.Write(span);
output.Write(delta);
output.Write(entry.Value);
}
}
}
public void Write(object obj)
{
if (obj == null)
{
Write(AmfTypeCode.Null);
return;
}
if (obj is IAmfSerializable)
{
((IAmfSerializable)obj).Serialize(this);
return;
}
if (obj is string)
{
Write((string)obj);
return;
}
if (obj is AmfObject)
{
Write((AmfObject)obj);
return;
}
if (obj is DateTime)
{
Write((DateTime)obj);
return;
}
if (obj is IList)
{
Write((IList)obj);
return;
}
if (obj is Amf3Wrapper)
{
Write(AmfTypeCode.Amf3Data);
amf3Writer.Write(((Amf3Wrapper)obj).Content);
return;
}
if (obj is Amf3Array ||
obj is Amf3Object)
{
Write(AmfTypeCode.Amf3Data);
amf3Writer.Write(obj);
return;
}
if (obj is bool)
{
Write((bool)obj);
return;
}
if (obj is byte ||
obj is sbyte ||
obj is short ||
obj is ushort ||
obj is int ||
obj is uint ||
obj is long ||
obj is ulong ||
obj is float ||
obj is double)
{
Write(Convert.ToDouble(obj));
return;
}
throw new ArgumentException("obj: Cannot serialize instance of type " + obj.GetType().FullName);
}
void IAmf3Serializable.Serialize(Amf3Writer writer)
{
writer.Write(this);
}
