public SlimSerializer(SlimFormat format)
{
if (format==null)
throw new SlimException(StringConsts.ARGUMENT_ERROR + "SlimSerializer.ctor(format=null)");
m_Format = format;
m_TypeMode = TypeRegistryMode.PerCall;
}
public SlimSerializer(SlimFormat format)
{
if (format == null)
{
throw new SlimException(StringConsts.ARGUMENT_ERROR + "SlimSerializer.ctor(format=null)");
}
m_Format = format;
m_TypeMode = TypeRegistryMode.PerCall;
}
/// <summary>
/// Emits MetaHandle that contains type handle for reference handle only when this referenced is added to pool for the first time.
/// Emits inlined string for strings and inlined value types for boxed objects.
/// Emits additional array dimensions info for array refernces who's types are emitted for the first time
/// </summary>
public MetaHandle GetHandle(object reference, TypeRegistry treg, SlimFormat format, out Type type)
{
Debug.Assert(m_Mode == SerializationOperation.Serializing, "GetHandle() called while deserializing", DebugAction.Throw);
if (reference == null)
{
type = null;
return(new MetaHandle(0));
}
type = reference.GetType();
if (type == typeof(string))
{
return(MetaHandle.InlineString(reference as string));
}
if (reference is Type)
{
var thandle = treg.GetTypeHandle(reference as Type);
return(MetaHandle.InlineTypeValue(thandle));
}
if (type.IsValueType)
{
var vth = treg.GetTypeHandle(type);
return(MetaHandle.InlineValueType(vth));
}
bool added;
uint handle = (uint)getIndex(reference, out added);
if (added)
{
var th = treg.GetTypeHandle(type);
if (format.IsRefTypeSupported(type))//20150305 Refhandle inline
{
return(MetaHandle.InlineRefType(th));
}
if (type.IsArray)//write array header like so: "System.int[,]|0~10,0~12" or "$3|0~10,0~12"
{
//DKh 20130712 Removed repetitive code that was refactored into Arrays class
var arr = (Array)reference;
th = new VarIntStr(Arrays.ArrayToDescriptor(arr, type, th));
}
return(new MetaHandle(handle, th));
}
return(new MetaHandle(handle));
}
/// <summary>
/// Emits MetaHandle that contains type handle for reference handle only when this referenced is added to pool for the first time.
/// Emits inlined string for strings and inlined value types for boxed objects.
/// Emits additional array dimensions info for array refernces who's types are emitted for the first time
/// </summary>
public MetaHandle GetHandle(object reference, TypeRegistry treg, SlimFormat format, out Type type)
{
if (reference == null)
{
type = null;
return(new MetaHandle(0));
}
if (reference is string)
{
type = typeof(string);
return(MetaHandle.InlineString(reference as string));
}
if (reference is Type)
{
type = typeof(Type);
var thandle = treg.GetTypeHandle(reference as Type);
return(MetaHandle.InlineTypeValue(thandle));
}
type = reference.GetType();
if (type.IsValueType)
{
var vth = treg.GetTypeHandle(type);
return(MetaHandle.InlineValueType(vth));
}
bool added;
uint handle = (uint)getIndex(reference, out added);
string th = added ? treg.GetTypeHandle(type) : null;
if (added)
{
if (format.IsRefTypeSupported(type))//20150305 Refhandle inline
{
return(MetaHandle.InlineRefType(th));
}
if (reference is Array)//write array header like so: "System.int[,]|0~10,0~12" or "$3|0~10,0~12"
{
//DKh 20130712 Removed repetitive code that was refactored into Arrays class
var arr = (Array)reference;
th = Arrays.ArrayToDescriptor(arr, treg, type, th);
}
}
return(new MetaHandle(handle, th));
}
/// <summary>
/// Returns object reference for supplied metahandle
/// </summary>
public object HandleToReference(MetaHandle handle, TypeRegistry treg, SlimFormat format, SlimReader reader)
{
Debug.Assert(m_Mode == SerializationOperation.Deserializing, "HandleToReference() called while serializing", DebugAction.Throw);
if (handle.IsInlinedString) return handle.Metadata.Value.StringValue;
if (handle.IsInlinedTypeValue)
{
var tref = treg[ handle.Metadata.Value ];//adding this type to registry if it is not there yet
return tref;
}
if (handle.IsInlinedRefType)
{
var tref = treg[ handle.Metadata.Value ];//adding this type to registry if it is not there yet
var ra = format.GetReadActionForRefType(tref);
if (ra!=null)
{
var inst = ra(reader);
m_List.Add(inst);
return inst;
}
else
throw new SlimDeserializationException("Internal error HandleToReference: no read action for ref type, but ref mhandle is inlined");
}
int idx = (int)handle.Handle;
if (idx<m_List.Count) return m_List[idx];
if (!handle.Metadata.HasValue)
throw new SlimDeserializationException(StringConsts.SLIM_HNDLTOREF_MISSING_TYPE_NAME_ERROR + handle.ToString());
Type type;
var metadata = handle.Metadata.Value;
if (metadata.StringValue!=null)//need to search for possible array descriptor
{
var ip = metadata.StringValue.IndexOf('|');//array descriptor start
if (ip>0)
{
var tname = metadata.StringValue.Substring(0, ip);
if (TypeRegistry.IsNullHandle(tname)) return null;
type = treg[ tname ];
}
else
{
if (TypeRegistry.IsNullHandle(metadata)) return null;
type = treg[ metadata ];
}
}
else
{
if (TypeRegistry.IsNullHandle(metadata)) return null;
type = treg[ metadata ];
}
object instance = null;
if (type.IsArray)
//DKh 20130712 Removed repetitive code that was refactored into Arrays class
instance = Arrays.DescriptorToArray(metadata.StringValue, type);
else
//20130715 DKh
instance = SerializationUtils.MakeNewObjectInstance(type);
m_List.Add(instance);
return instance;
}
/// <summary>
/// Emits MetaHandle that contains type handle for reference handle only when this referenced is added to pool for the first time.
/// Emits inlined string for strings and inlined value types for boxed objects.
/// Emits additional array dimensions info for array refernces who's types are emitted for the first time
/// </summary>
public MetaHandle GetHandle(object reference, TypeRegistry treg, SlimFormat format, out Type type)
{
Debug.Assert(m_Mode == SerializationOperation.Serializing, "GetHandle() called while deserializing", DebugAction.Throw);
if (reference==null)
{
type = null;
return new MetaHandle(0);
}
type = reference.GetType();
if (type == typeof(string))
{
return MetaHandle.InlineString(reference as string);
}
if (reference is Type)
{
var thandle = treg.GetTypeHandle(reference as Type);
return MetaHandle.InlineTypeValue(thandle);
}
if (type.IsValueType)
{
var vth = treg.GetTypeHandle(type);
return MetaHandle.InlineValueType(vth);
}
bool added;
uint handle = (uint)getIndex(reference, out added);
if (added)
{
var th = treg.GetTypeHandle(type);
if (format.IsRefTypeSupported(type))//20150305 Refhandle inline
return MetaHandle.InlineRefType(th);
if (type.IsArray)//write array header like so: "System.int[,]|0~10,0~12" or "$3|0~10,0~12"
{
//DKh 20130712 Removed repetitive code that was refactored into Arrays class
var arr = (Array)reference;
th = new VarIntStr( Arrays.ArrayToDescriptor(arr, type, th) );
}
return new MetaHandle(handle, th);
}
return new MetaHandle(handle);
}
/// <summary>
/// Returns object reference for supplied metahandle
/// </summary>
public object HandleToReference(MetaHandle handle, TypeRegistry treg, SlimFormat format, SlimReader reader)
{
Debug.Assert(m_Mode == SerializationOperation.Deserializing, "HandleToReference() called while serializing", DebugAction.Throw);
if (handle.IsInlinedString)
{
return(handle.Metadata.Value.StringValue);
}
if (handle.IsInlinedTypeValue)
{
var tref = treg[handle.Metadata.Value];//adding this type to registry if it is not there yet
return(tref);
}
if (handle.IsInlinedRefType)
{
var tref = treg[handle.Metadata.Value];//adding this type to registry if it is not there yet
var ra = format.GetReadActionForRefType(tref);
if (ra != null)
{
var inst = ra(reader);
m_List.Add(inst);
return(inst);
}
else
{
throw new SlimDeserializationException("Internal error HandleToReference: no read action for ref type, but ref mhandle is inlined");
}
}
int idx = (int)handle.Handle;
if (idx < m_List.Count)
{
return(m_List[idx]);
}
if (!handle.Metadata.HasValue)
{
throw new SlimDeserializationException(StringConsts.SLIM_HNDLTOREF_MISSING_TYPE_NAME_ERROR + handle.ToString());
}
Type type;
var metadata = handle.Metadata.Value;
if (metadata.StringValue != null) //need to search for possible array descriptor
{
var ip = metadata.StringValue.IndexOf('|'); //array descriptor start
if (ip > 0)
{
var tname = metadata.StringValue.Substring(0, ip);
if (TypeRegistry.IsNullHandle(tname))
{
return(null);
}
type = treg[tname];
}
else
{
if (TypeRegistry.IsNullHandle(metadata))
{
return(null);
}
type = treg[metadata];
}
}
else
{
if (TypeRegistry.IsNullHandle(metadata))
{
return(null);
}
type = treg[metadata];
}
object instance = null;
if (type.IsArray)
{
//DKh 20130712 Removed repetitive code that was refactored into Arrays class
instance = Arrays.DescriptorToArray(metadata.StringValue, type);
}
else
{
//20130715 DKh
instance = SerializationUtils.MakeNewObjectInstance(type);
}
m_List.Add(instance);
return(instance);
}
public TypeSchema(SlimFormat format)
{
m_Format = format;
}
internal SlimSerializer(TypeRegistry global, SlimFormat format) : this(format)
{
__globalTypeRegistry = global;
m_GlobalTypes = new IEnumerable <Type>[] { global.ToArray() };
m_SkipTypeRegistryCrosschecks = true;
}
public SlimSerializer(SlimFormat format, params IEnumerable <Type>[] globalTypes) : this(format)
{
m_GlobalTypes = globalTypes;
}
internal SlimSerializer(TypeRegistry global, SlimFormat format) : this(format)
{
__globalTypeRegistry = global;
m_GlobalTypes = new IEnumerable<Type>[]{ global.ToArray() };
m_SkipTypeRegistryCrosschecks = true;
}
public SlimSerializer(SlimFormat format, params IEnumerable<Type>[] globalTypes) : this(format)
{
m_GlobalTypes = globalTypes;
}
/// <summary>
/// Returns object reference for supplied metahandle
/// </summary>
public object HandleToReference(MetaHandle handle, TypeRegistry treg, SlimFormat format, SlimReader reader)
{
if (handle.IsInlinedString) return handle.Metadata;
if (handle.IsInlinedTypeValue)
{
var tref = treg.GetByHandle(handle.Metadata);//adding this type to registry if it is not there yet
return tref;
}
if (handle.IsInlinedRefType)
{
var tref = treg.GetByHandle(handle.Metadata);//adding this type to registry if it is not there yet
var ra = format.GetReadActionForRefType(tref);
if (ra!=null)
{
var inst = ra(reader);
m_List.Add(inst);
m_Dict.Add(inst, m_List.Count - 1);
return inst;
}
else
throw new SlimDeserializationException("Internal error HandleToReference: no read action for ref type, but ref mhandle is inlined");
}
int idx = (int)handle.Handle;
if (idx<m_List.Count) return m_List[idx];
if (string.IsNullOrEmpty(handle.Metadata))
throw new SlimDeserializationException(StringConsts.SLIM_HNDLTOREF_MISSING_TYPE_NAME_ERROR + handle.ToString());
var metadata = handle.Metadata;
var ip = metadata.IndexOf('|');
//var segments = metadata.Split('|');
var th = ip>0 ? metadata.Substring(0, ip) : metadata;
//20140701 DKh
var type = treg[th];//segments[0]];
object instance = null;
if (type.IsArray)
//DKh 20130712 Removed repetitive code that was refactored into Arrays class
instance = Arrays.DescriptorToArray(metadata, treg, type);
else
//20130715 DKh
instance = SerializationUtils.MakeNewObjectInstance(type);
m_List.Add(instance);
m_Dict.Add(instance, m_List.Count - 1);
return instance;
}
/// <summary>
/// Emits MetaHandle that contains type handle for reference handle only when this referenced is added to pool for the first time.
/// Emits inlined string for strings and inlined value types for boxed objects.
/// Emits additional array dimensions info for array refernces who's types are emitted for the first time
/// </summary>
public MetaHandle GetHandle(object reference, TypeRegistry treg, SlimFormat format, out Type type)
{
if (reference==null)
{
type = null;
return new MetaHandle(0);
}
if (reference is string)
{
type = typeof(string);
return MetaHandle.InlineString(reference as string);
}
if (reference is Type)
{
type = typeof(Type);
var thandle = treg.GetTypeHandle(reference as Type);
return MetaHandle.InlineTypeValue(thandle);
}
type = reference.GetType();
if (type.IsValueType)
{
var vth = treg.GetTypeHandle(type);
return MetaHandle.InlineValueType(vth);
}
bool added;
uint handle = (uint)getIndex(reference, out added);
string th = added ? treg.GetTypeHandle(type) : null;
if (added)
{
if (format.IsRefTypeSupported(type))//20150305 Refhandle inline
return MetaHandle.InlineRefType(th);
if (reference is Array)//write array header like so: "System.int[,]|0~10,0~12" or "$3|0~10,0~12"
{
//DKh 20130712 Removed repetitive code that was refactored into Arrays class
var arr = (Array)reference;
th = Arrays.ArrayToDescriptor(arr, treg, type, th);
}
}
return new MetaHandle(handle, th);
}
/// <summary>
/// Returns object reference for supplied metahandle
/// </summary>
public object HandleToReference(MetaHandle handle, TypeRegistry treg, SlimFormat format, SlimReader reader)
{
if (handle.IsInlinedString)
{
return(handle.Metadata);
}
if (handle.IsInlinedTypeValue)
{
var tref = treg.GetByHandle(handle.Metadata);//adding this type to registry if it is not there yet
return(tref);
}
if (handle.IsInlinedRefType)
{
var tref = treg.GetByHandle(handle.Metadata);//adding this type to registry if it is not there yet
var ra = format.GetReadActionForRefType(tref);
if (ra != null)
{
var inst = ra(reader);
m_List.Add(inst);
m_Dict.Add(inst, m_List.Count - 1);
return(inst);
}
else
{
throw new SlimDeserializationException("Internal error HandleToReference: no read action for ref type, but ref mhandle is inlined");
}
}
int idx = (int)handle.Handle;
if (idx < m_List.Count)
{
return(m_List[idx]);
}
if (string.IsNullOrEmpty(handle.Metadata))
{
throw new SlimDeserializationException(StringConsts.SLIM_HNDLTOREF_MISSING_TYPE_NAME_ERROR + handle.ToString());
}
var metadata = handle.Metadata;
var ip = metadata.IndexOf('|');
//var segments = metadata.Split('|');
var th = ip > 0 ? metadata.Substring(0, ip) : metadata;
//20140701 DKh
var type = treg[th];//segments[0]];
object instance = null;
if (type.IsArray)
{
//DKh 20130712 Removed repetitive code that was refactored into Arrays class
instance = Arrays.DescriptorToArray(metadata, treg, type);
}
else
{
//20130715 DKh
instance = SerializationUtils.MakeNewObjectInstance(type);
}
m_List.Add(instance);
m_Dict.Add(instance, m_List.Count - 1);
return(instance);
}
