/// <summary>
///
/// </summary>
/// <param name="userType"></param>
/// <param name="typeId"></param>
/// <returns></returns>
public IPortableTypeDescriptor Descriptor(bool userType, int typeId)
{
IPortableTypeDescriptor desc;
return(_idToDesc.TryGetValue(PortableUtils.TypeKey(userType, typeId), out desc) ? desc :
userType ? new PortableSurrogateTypeDescriptor(_cfg, typeId) : null);
}
/// <summary>
/// Add type.
/// </summary>
/// <param name="type">Type.</param>
/// <param name="typeId">Type ID.</param>
/// <param name="typeName">Type name.</param>
/// <param name="userType">User type flag.</param>
/// <param name="metaEnabled">Metadata enabled flag.</param>
/// <param name="keepDeserialized">Whether to cache deserialized value in IPortableObject</param>
/// <param name="nameMapper">Name mapper.</param>
/// <param name="idMapper">ID mapper.</param>
/// <param name="serializer">Serializer.</param>
/// <param name="affKeyFieldName">Affinity key field name.</param>
/// <param name="typedHandler">Typed handler.</param>
/// <param name="untypedHandler">Untyped handler.</param>
private void AddType(Type type, int typeId, string typeName, bool userType, bool metaEnabled,
bool keepDeserialized, IPortableNameMapper nameMapper, IPortableIdMapper idMapper,
IPortableSerializer serializer, string affKeyFieldName, object typedHandler,
PortableSystemWriteDelegate untypedHandler)
{
long typeKey = PortableUtils.TypeKey(userType, typeId);
if (_idToDesc.ContainsKey(typeKey))
{
string type1 = _idToDesc[typeKey].Type != null ? _idToDesc[typeKey].Type.AssemblyQualifiedName : null;
string type2 = type != null ? type.AssemblyQualifiedName : null;
throw new PortableException("Conflicting type IDs [type1=" + type1 + ", type2=" + type2 +
", typeId=" + typeId + ']');
}
if (userType && _typeNameToDesc.ContainsKey(typeName))
{
throw new PortableException("Conflicting type name: " + typeName);
}
IPortableTypeDescriptor descriptor =
new PortableFullTypeDescriptor(type, typeId, typeName, userType, nameMapper, idMapper, serializer,
metaEnabled, keepDeserialized, affKeyFieldName, typedHandler, untypedHandler);
if (type != null)
{
_typeToDesc[type] = descriptor;
}
if (userType)
{
_typeNameToDesc[typeName] = descriptor;
}
_idToDesc[typeKey] = descriptor;
}
private T ReadFullObject <T>(int pos)
{
// Read header.
bool userType = Stream.ReadBool();
int typeId = Stream.ReadInt();
// ReSharper disable once UnusedVariable
int hashCode = Stream.ReadInt();
int len = Stream.ReadInt();
int rawOffset = Stream.ReadInt();
try
{
// Already read this object?
object hndObj;
if (_hnds != null && _hnds.TryGetValue(pos, out hndObj))
{
return((T)hndObj);
}
if (userType && _mode == PortableMode.ForcePortable)
{
PortableUserObject portObj;
if (_detach)
{
Stream.Seek(pos, SeekOrigin.Begin);
portObj = GetPortableUserObject(pos, 0, Stream.ReadByteArray(len));
}
else
{
portObj = GetPortableUserObject(pos, pos, Stream.Array());
}
T obj = _builder == null ? TypeCaster <T> .Cast(portObj) : TypeCaster <T> .Cast(_builder.Child(portObj));
AddHandle(pos, obj);
return(obj);
}
else
{
// Find descriptor.
IPortableTypeDescriptor desc;
if (!_descs.TryGetValue(PortableUtils.TypeKey(userType, typeId), out desc))
{
throw new PortableException("Unknown type ID: " + typeId);
}
// Instantiate object.
if (desc.Type == null)
{
throw new PortableException("No matching type found for object [typeId=" +
desc.TypeId + ", typeName=" + desc.TypeName + ']');
}
// Preserve old frame.
int oldTypeId = _curTypeId;
int oldPos = _curPos;
int oldRawOffset = _curRawOffset;
IPortableNameMapper oldConverter = _curConverter;
IPortableIdMapper oldMapper = _curMapper;
bool oldRaw = _curRaw;
// Set new frame.
_curTypeId = typeId;
_curPos = pos;
_curRawOffset = rawOffset;
_curConverter = desc.NameConverter;
_curMapper = desc.Mapper;
_curRaw = false;
// Read object.
object obj;
var sysSerializer = desc.Serializer as IPortableSystemTypeSerializer;
if (sysSerializer != null)
{
obj = sysSerializer.ReadInstance(this);
}
else
{
try
{
obj = FormatterServices.GetUninitializedObject(desc.Type);
// Save handle.
AddHandle(pos, obj);
}
catch (Exception e)
{
throw new PortableException("Failed to create type instance: " +
desc.Type.AssemblyQualifiedName, e);
}
desc.Serializer.ReadPortable(obj, this);
}
// Restore old frame.
_curTypeId = oldTypeId;
_curPos = oldPos;
_curRawOffset = oldRawOffset;
_curConverter = oldConverter;
_curMapper = oldMapper;
_curRaw = oldRaw;
var wrappedSerializable = obj as SerializableObjectHolder;
return(wrappedSerializable != null ? (T)wrappedSerializable.Item : (T)obj);
}
}
finally
{
// Advance stream pointer.
Stream.Seek(pos + len, SeekOrigin.Begin);
}
}
