public object Deserialize(CacheItem item)
{
if (item.Segment.Array == null)
{
return(null);
}
if (item.Flags == RawDataFlag || (item.Flags & 0x1ff) != item.Flags)
{
var tmp = item.Segment;
if (tmp.Count == tmp.Array.Length)
{
return(tmp.Array);
}
// TODO improve memcpy
var retval = new byte[tmp.Count];
Buffer.BlockCopy(tmp.Array, 0, retval, 0, tmp.Count);
return(retval);
}
var code = (TypeCode)(item.Flags & 0xff);
var data = item.Segment;
switch (code)
{
case TypeCode.DBNull: return(null);
// incrementing a non-existing key then getting it
// returns as a string, but the flag will be 0
// so treat all 0 flagged items as string
// this may help inter-client data management as well
case TypeCode.Empty:
case TypeCode.String: return(DeserializeString(data));
case TypeCode.Byte: return(data.Array[0]);
case TypeCode.SByte: return((sbyte)data.Array[0]);
case TypeCode.Boolean: return(PooledBitConverter.ToBoolean(data));
case TypeCode.Char: return(PooledBitConverter.ToChar(data));
case TypeCode.Int16: return(PooledBitConverter.ToInt16(data));
case TypeCode.Int32: return(PooledBitConverter.ToInt32(data));
case TypeCode.Int64: return(PooledBitConverter.ToInt64(data));
case TypeCode.UInt16: return(PooledBitConverter.ToUInt16(data));
case TypeCode.UInt32: return(PooledBitConverter.ToUInt32(data));
case TypeCode.UInt64: return(PooledBitConverter.ToUInt64(data));
case TypeCode.DateTime: return(DateTime.FromBinary(PooledBitConverter.ToInt64(data)));
case TypeCode.Single: return(PooledBitConverter.ToSingle(data));
case TypeCode.Double: return(PooledBitConverter.ToDouble(data));
case TypeCode.Decimal: return(PooledBitConverter.ToDecimal(data));
case TypeCode.Object: return(DeserializeObject(data));
default: throw new InvalidOperationException("Unknown TypeCode was returned: " + code);
}
}
public CacheItem Serialize(object value)
{
// - or we just received a byte[]. No further processing is needed.
var tmpByteArray = value as byte[];
if (tmpByteArray != null)
{
return(new CacheItem(RawDataFlag, new PooledSegment(tmpByteArray, tmpByteArray.Length)));
}
// got some real data, serialize it
var code = value == null
? TypeCode.DBNull
: Type.GetTypeCode(value.GetType());
PooledSegment data;
switch (code)
{
case TypeCode.Empty:
case TypeCode.DBNull: data = PooledSegment.Empty; break;
case TypeCode.String: data = SerializeString((String)value); break;
case TypeCode.SByte: data = PooledBitConverter.GetBytes(allocator, (SByte)value); break;
case TypeCode.Byte: data = PooledBitConverter.GetBytes(allocator, (Byte)value); break;
case TypeCode.Boolean: data = PooledBitConverter.GetBytes(allocator, (Boolean)value); break;
case TypeCode.Char: data = PooledBitConverter.GetBytes(allocator, (Char)value); break;
case TypeCode.Int16: data = PooledBitConverter.GetBytes(allocator, (Int16)value); break;
case TypeCode.Int32: data = PooledBitConverter.GetBytes(allocator, (Int32)value); break;
case TypeCode.Int64: data = PooledBitConverter.GetBytes(allocator, (Int64)value); break;
case TypeCode.UInt16: data = PooledBitConverter.GetBytes(allocator, (UInt16)value); break;
case TypeCode.UInt32: data = PooledBitConverter.GetBytes(allocator, (UInt32)value); break;
case TypeCode.UInt64: data = PooledBitConverter.GetBytes(allocator, (UInt64)value); break;
case TypeCode.DateTime: data = PooledBitConverter.GetBytes(allocator, ((DateTime)value).ToBinary()); break;
case TypeCode.Single: data = PooledBitConverter.GetBytes(allocator, (Single)value); break;
case TypeCode.Double: data = PooledBitConverter.GetBytes(allocator, (Double)value); break;
case TypeCode.Decimal: data = PooledBitConverter.GetBytes(allocator, (Decimal)value); break;
case TypeCode.Object:
// raw data is a special case when someone passes in a buffer (byte[] or ArraySegment<byte>)
// ArraySegment<byte> is only passed in when a part of buffer is being
// serialized, usually from a MemoryStream (To avoid duplicating arrays
// the byte[] returned by MemoryStream.GetBuffer is placed into an ArraySegment.)
if (value is ArraySegment <byte> )
{
return(new CacheItem(RawDataFlag, PooledSegment.From((ArraySegment <byte>)value)));
}
data = SerializeObject(value); break;
default: throw new InvalidOperationException("Unknown TypeCode was returned: " + code);
}
return(new CacheItem((uint)((int)code | 0x100), data));
}
