public static void RegisterSerializer(string aliasName, IAmf3Serializer serializer)
{
lock (sAliasToSerializer)
{
sAliasToSerializer[aliasName] = serializer;
}
}
// gets registered serializer associated with class alias
public static IAmf3Serializer GetSerializerFromAlias(string aliasName)
{
lock (sAliasToSerializer)
{
IAmf3Serializer serializer = null;
sAliasToSerializer.TryGetValue(aliasName, out serializer);
return(serializer);
}
}
public void WriteDefaultObjectForType(Type type)
{
// get serializer
IAmf3Serializer serializer = GetSerializerForType(type);
// create default instance
var defaultInstance = serializer.NewInstance(null);
// write object using serializer
serializer.WriteObject(this, defaultInstance);
}
// gets serializer for a class alias string
private IAmf3Serializer GetSerializerFromAlias(string alias)
{
IAmf3Serializer serializer = Amf3ClassDef.GetSerializerFromAlias(alias);
if (serializer == null)
{
var type = Amf3ClassDef.GetTypeFromAlias(alias);
if (type != null)
{
// create reflection serializer
serializer = new ReflectionSerializer(alias, type, true, false);
// automatically register it
Amf3ClassDef.RegisterSerializer(alias, serializer);
}
}
return(serializer);
}
public object ReadVectorObject()
{
int num = ReadInteger();
if ((num & 1) == 0)
{
return(GetTableEntry(objectTable, num >> 1));
}
num >>= 1;
bool isFixed = ReadByte() != 0;
// read object type name
// this class definition is not known until the first object has been read, but we don't need it here
string objectTypeName = ReadString();
// get serializer for class alias
IAmf3Serializer serializer = GetSerializerFromAlias(objectTypeName);
IList vector;
if (serializer != null)
{
// create vector using serializer
vector = serializer.NewVector((uint)num, isFixed);
}
else
{
// create a new vector of dynamic
vector = new _root.Vector <dynamic>((uint)num, isFixed);
}
objectTable.Add(vector);
// read all values
for (int i = 0; i < num; i++)
{
vector[i] = ReadNextObject();
}
return(vector);
}
public Amf3Parser(byte[] data, int offset, int length, bool autoSetCapacity = true)
{
// set data source
mData = data;
mPosition = offset;
mLength = length;
// set default serializer
if (UseExpandoAsDefault)
{
this.DefaultSerializer = new ExpandoSerializer();
}
else
{
this.DefaultSerializer = new Amf3Object.Serializer();
}
if (autoSetCapacity)
{
AutoSetCapacity();
}
}
public object ReadAmf3Object()
{
Amf3Object.Flags flags = (Amf3Object.Flags)ReadInteger();
if ((flags & Amf3Object.Flags.Inline) == 0)
{
return(GetTableEntry(objectTable, ((int)flags) >> 1));
}
Amf3ClassDef classDef;
if ((flags & Amf3Object.Flags.InlineClassDef) == 0)
{
classDef = GetTableEntry(traitTable, ((int)flags) >> 2);
}
else
{
classDef = ReadAmf3ClassDef(flags);
}
// get the serializer to use (start with the override serializer)
IAmf3Serializer serializer = OverrideSerializer;
if (serializer == null)
{
// no override? get serializer from class definition
serializer = classDef.Serializer;
if (serializer == null)
{
// no serializer for class definition? use default serializer
serializer = DefaultSerializer;
}
}
// fast path the Amf3Object serializer
if (serializer is Amf3Object.Serializer)
{
var obj = new Amf3Object(classDef);
// add to object table
objectTable.Add(obj);
// read all properties into object
int count = classDef.Properties.Length;
for (int i = 0; i < count; i++)
{
ReadNextObject(ref obj.Values[i]);
}
// read dynamic properties
if (classDef.Dynamic)
{
string key = ReadString();
while (key != "")
{
var value = ReadNextObject();
obj.SetPropertyValueAsObject(key, value);
key = ReadString();
}
}
return(obj);
}
else
{
// create object instance using serializer
object obj = serializer.NewInstance(classDef);
// add to object table
objectTable.Add(obj);
// begin property remapping
var reader = classDef.CreatePropertyReader();
reader.BeginRead(this);
// read object using serializer
serializer.ReadObject(reader, obj);
// end property remapping
classDef.ReleasePropertyReader(reader);
// read dynamic properties
if (classDef.Dynamic)
{
var dc = obj as PlayScript.IDynamicClass;
string key = ReadString();
while (key != "")
{
var value = ReadNextObject();
if (dc != null)
{
dc.__SetDynamicValue(key, value);
}
key = ReadString();
}
}
return(obj);
}
}
public void Write(object obj)
{
if (obj == null)
{
Write(Amf3TypeCode.Null);
return;
}
var serializable = obj as IAmf3Writable;
if (serializable != null)
{
serializable.Serialize(this);
return;
}
var str = obj as string;
if (str != null)
{
Write(str);
return;
}
var expando = obj as ExpandoObject;
if (expando != null)
{
Write(expando);
return;
}
if (obj is bool)
{
Write((bool)obj);
return;
}
if (obj is double)
{
Write((double)obj);
return;
}
if (obj is float)
{
Write((double)(float)obj);
return;
}
if (obj is int)
{
Write((int)obj);
return;
}
if (obj is uint)
{
Write((int)(uint)obj);
return;
}
if (obj is _root.Date)
{
Write((_root.Date)obj);
return;
}
if (obj is IList)
{
Write((IList)obj);
return;
}
if (obj is flash.utils.ByteArray)
{
Write((flash.utils.ByteArray)obj);
return;
}
if (obj is flash.utils.Dictionary)
{
Write((flash.utils.Dictionary)obj);
return;
}
if (obj is byte ||
obj is sbyte ||
obj is short ||
obj is ushort)
{
Write(Convert.ToInt32(obj));
return;
}
// get serializer from type
var type = obj.GetType();
IAmf3Serializer serializer = GetSerializerForType(type);
// write object using serializer
serializer.WriteObject(this, obj);
}
