/// <summary>
/// Serializes the specified object.
/// </summary>
/// <param name="obj">The object.</param>
/// <returns></returns>
public byte[] Serialize(IFastBinarySerializable obj)
{
using (var container = Pool.Container())
{
return(container.Instance.Serialize(obj));
}
}
/// <summary>
/// Writes the specified object.
/// </summary>
/// <param name="obj">The object.</param>
/// <param name="additionalInfo">The additional information.</param>
public void Write(IFastBinarySerializable obj, object additionalInfo)
{
if (WriteNullState(obj))
{
WriteData(obj, additionalInfo);
}
}
/// <summary>
/// Serializes the specified stream.
/// </summary>
/// <param name="stream">The stream.</param>
/// <param name="obj">The object.</param>
public void Serialize(Stream stream, IFastBinarySerializable obj)
{
using (var container = Pool.Container())
{
container.Instance.Serialize(stream, obj);
}
}
/// <summary>
/// Serializes the specified graph.
/// </summary>
/// <param name="graph">The graph.</param>
/// <param name="additionalInfo">The additional information.</param>
/// <returns></returns>
public byte[] Serialize(IFastBinarySerializable graph, object additionalInfo)
{
using (var ms = new MemoryStream())
{
Serialize(ms, graph, additionalInfo);
return(ms.ToArray());
}
}
public void AddExtraData(IFastBinarySerializable data)
{
if (data == null)
{
return;
}
AddExtraData(data.GetType().Name, data);
}
public void SetObject(FastBinaryFormatter ff, IFastBinarySerializable obj)
{
ObjectData = null;
if (obj == null)
{
return;
}
ObjectData = ff.Serialize(obj);
}
private void WriteRequest(MessageRequestType requestType, IFastBinarySerializable request)
{
Byte[] bData = null;
using (var pool = FastFormatterPool.Pool.Container())
{
bData = pool.Instance.Serialize(new MessageHeader(pool.Instance, requestType, request));
}
MessageWriter.Write(bData);
}
public void SetExtraData(FastBinaryFormatter ff, IFastBinarySerializable data)
{
FExtraData = null;
FExtraDataTypeHash = 0;
if (data != null)
{
FExtraData = new FastSerializerObjectData(ff, data);
FExtraDataTypeHash = (Int32)data.GetType().Name.BKDRHash();
}
}
public void SetSubDetails(IFastBinarySerializable subDetails)
{
if (subDetails == null)
{
return;
}
using (var pool = FastFormatterPool.Pool.Container())
{
FSubDetails = new FastSerializerObjectData(pool.Instance, subDetails);
}
}
/// <summary>
/// Sets the object.
/// </summary>
/// <param name="obj">The object.</param>
public void SetObject(IFastBinarySerializable obj)
{
ObjectData = null;
if (obj == null)
{
return;
}
using (var ff = new FastBinaryFormatter())
{
SetObject(ff, obj);
}
}
/// <summary>
/// Writes the data.
/// </summary>
/// <param name="graph">The graph.</param>
/// <param name="additionalInfo">The additional information.</param>
internal void WriteData(IFastBinarySerializable graph, object additionalInfo)
{
var startOfGraphPos = (int)BaseStream.Position;
Write(FLengthBuffer, 0, FLengthBuffer.Length);
graph.WriteData(this, additionalInfo);
var graphSize = (int)BaseStream.Position - startOfGraphPos - FLengthBuffer.Length;
BaseStream.Position = startOfGraphPos;
var bGraphSize = BitConverter.GetBytes(graphSize);
Write(bGraphSize, 0, bGraphSize.Length);
Seek(0, SeekOrigin.End);
}
public void AddExtraData(String dataName, IFastBinarySerializable data)
{
if (data == null)
{
return;
}
if (FExtraData == null)
{
FExtraData = new Dictionary <Int32, FastSerializerObjectData>();
}
FExtraData[(Int32)dataName.ToLower().BKDRHash()] = new FastSerializerObjectData(data);
}
/// <summary>
/// Serializes the specified serialization stream.
/// </summary>
/// <param name="serializationStream">The serialization stream.</param>
/// <param name="graph">The graph.</param>
/// <param name="additionalInfo">The additional information.</param>
public void Serialize(Stream serializationStream, IFastBinarySerializable graph, object additionalInfo)
{
try
{
FMemoryStream.Seek(0, SeekOrigin.Begin);
FWriter.WriteData(graph, additionalInfo);
var bRootGraphSize = BitConverter.GetBytes((int)FMemoryStream.Position);
serializationStream.Write(bRootGraphSize, 0, bRootGraphSize.Length);
serializationStream.Write(FMemoryStream.GetBuffer(), 0, (int)FMemoryStream.Position);
}
finally
{
FMemoryStream.SetLength(0);
FMemoryStream.Capacity = STREAM_MAX_CAPACITY;
}
}
/// <summary>
/// Writes the hashed directory.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="dictionary">The dictionary.</param>
public void WriteHashedDirectory <T>(Dictionary <int, T> dictionary) where T : IFastBinarySerializable
{
if (WriteNullState(dictionary))
{
var keys = new int[dictionary.Count];
var values = new IFastBinarySerializable[dictionary.Count];
dictionary.Keys.CopyTo(keys, 0);
for (var i = 0; i < keys.Length; i++)
{
values[i] = dictionary[keys[i]];
}
Write(keys);
Write(values);
}
}
/// <summary>
/// Reads the data.
/// </summary>
/// <param name="graph">The graph.</param>
/// <param name="additionalInfo">The additional information.</param>
internal void ReadData(IFastBinarySerializable graph, object additionalInfo)
{
var lastActiveObject = CurrentActiveObjectStates;
CurrentActiveObjectStates = new ActiveObjectStates();
Read(FLengthBuffer, 0, FLengthBuffer.Length);
CurrentActiveObjectStates.GraphSize = BitConverter.ToInt32(FLengthBuffer, 0);
CurrentActiveObjectStates.StartOfGraphPos = (int)BaseStream.Position;
graph.ReadData(this, additionalInfo);
var remainingSize = GetActiveObjectRemainingSize();
if (remainingSize > 0)
{
BaseStream.Seek(remainingSize, SeekOrigin.Current);
}
CurrentActiveObjectStates = lastActiveObject;
}
public void SetDetails(IFastBinarySerializable details, Boolean bSetType)
{
if (details == null)
{
if (bSetType)
{
FDetailType = 0;
}
return;
}
if (bSetType)
{
FDetailType = (Int32)details.GetType().FullName.BKDRHash();
}
using (var pool = FastFormatterPool.Pool.Container())
{
FDetails = new FastSerializerObjectData(pool.Instance, details);
}
}
} // depending on the request type, this blob can either be a MessageRequest or MessageSequence object
public MessageHeader(FastBinaryFormatter ff, MessageRequestType requestType, IFastBinarySerializable request)
{
RequestType = requestType;
Request = new FastSerializerObjectData(ff, request);
}
/// <summary>
/// Initializes a new instance of the <see cref="FastSerializerObjectData"/> class.
/// </summary>
/// <param name="obj">The object.</param>
public FastSerializerObjectData(IFastBinarySerializable obj)
{
SetObject(obj);
}
/// <summary>
/// Writes the specified object.
/// </summary>
/// <param name="obj">The object.</param>
public void Write(IFastBinarySerializable obj)
{
Write(obj, null);
}
/// <summary>
/// Initializes a new instance of the <see cref="FastSerializerObjectData"/> class.
/// </summary>
/// <param name="ff">The ff.</param>
/// <param name="obj">The object.</param>
public FastSerializerObjectData(FastBinaryFormatter ff, IFastBinarySerializable obj)
{
SetObject(ff, obj);
}
/// <summary>
/// Serializes the specified graph.
/// </summary>
/// <param name="graph">The graph.</param>
/// <returns></returns>
public byte[] Serialize(IFastBinarySerializable graph)
{
return(Serialize(graph, null));
}
/// <summary>
/// Serializes the specified serialization stream.
/// </summary>
/// <param name="serializationStream">The serialization stream.</param>
/// <param name="graph">The graph.</param>
public void Serialize(Stream serializationStream, IFastBinarySerializable graph)
{
Serialize(serializationStream, graph, null);
}
public void SetDetails(IFastBinarySerializable details)
{
SetDetails(details, true);
}
