public object Deserialize(CacheItem item) { var jsonSerializer = new JsonSerializer { TypeNameHandling = TypeNameHandling.All }; var data = new byte[item.Data.Count]; Array.Copy(item.Data.Array, item.Data.Offset, data, 0, data.Length); using (var memoryStream = new MemoryStream(data)) { using (var zipStream = new GZipStream(memoryStream, CompressionMode.Decompress)) { using (var streamReader = new StreamReader(zipStream)) { var textReader = new JsonTextReader(streamReader); try { return jsonSerializer.Deserialize(textReader); } catch (JsonSerializationException) { //This exception occurs if whatever is in memcached is impossible to deserialize. It's a tricky case, but we'll have to report back that nothing is in there. return null; } } } } }
public object Deserialize(CacheItem item) { var jsonSerializer = new JsonSerializer { TypeNameHandling = TypeNameHandling.All }; var data = new byte[item.Data.Count]; Array.Copy(item.Data.Array, item.Data.Offset, data, 0, data.Length); using (var memoryStream = new MemoryStream(data)) { using (var streamReader = new StreamReader(memoryStream)) { var textReader = new JsonTextReader(streamReader); try { var dynamicEntity = jsonSerializer.Deserialize(textReader); return dynamicEntity; } catch (JsonReaderException) { return null; } catch (JsonSerializationException) { return null; } } } }
public object Deserialize(CacheItem item) { var jsonSerializer = new JsonSerializer { TypeNameHandling = TypeNameHandling.All }; using (var memoryStream = new MemoryStream(item.Data.Array)) { using (var streamReader = new StreamReader(memoryStream)) { var textReader = new JsonTextReader(streamReader); try { var dynamicEntity = jsonSerializer.Deserialize(textReader); return dynamicEntity; } catch(JsonReaderException e) { return new object(); } } } }
protected virtual object Deserialize(CacheItem item) { if (item.Data.Array == null) return null; if (item.Flags == RawDataFlag) { var tmp = item.Data; if (tmp.Count == tmp.Array.Length) return tmp.Array; // we should never arrive here, but it's better to be safe than sorry var retval = new byte[tmp.Count]; Array.Copy(tmp.Array, tmp.Offset, retval, 0, tmp.Count); return retval; } var code = (TypeCode)(item.Flags & 0xff); var data = item.Data; switch (code) { // 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 // // however we store 'null' as Empty + an empty array, // so this must special-cased for compatibilty with // earlier versions. we introduced DBNull as null marker in emc2.6 case TypeCode.Empty: return (data.Array == null || data.Count == 0) ? null : DeserializeString(data); case TypeCode.DBNull: return null; case TypeCode.String: return this.DeserializeString(data); case TypeCode.Boolean: return this.DeserializeBoolean(data); case TypeCode.Int16: return this.DeserializeInt16(data); case TypeCode.Int32: return this.DeserializeInt32(data); case TypeCode.Int64: return this.DeserializeInt64(data); case TypeCode.UInt16: return this.DeserializeUInt16(data); case TypeCode.UInt32: return this.DeserializeUInt32(data); case TypeCode.UInt64: return this.DeserializeUInt64(data); case TypeCode.Char: return this.DeserializeChar(data); case TypeCode.DateTime: return this.DeserializeDateTime(data); case TypeCode.Double: return this.DeserializeDouble(data); case TypeCode.Single: return this.DeserializeSingle(data); // backward compatibility // earlier versions serialized decimals with TypeCode.Decimal // even though they were saved by BinaryFormatter case TypeCode.Decimal: case TypeCode.Object: return this.DeserializeObject(data); default: throw new InvalidOperationException("Unknown TypeCode was returned: " + code); } }
public IStoreOperation Store(StoreMode mode, Key key, CacheItem value, uint expires, ulong cas) { return new StoreOperation(allocator, mode, key, value) { Cas = cas, Expires = expires }; }
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); } }
object ITranscoder.Deserialize(CacheItem item) { switch (item.Flag) { case ProtoIdentifier: var segment = item.Data; byte[] raw = segment.Array; int count = segment.Count, offset = segment.Offset; Type type = ReadType(raw, ref offset, ref count); using (var ms = new MemoryStream(raw, offset, count)) { return Serializer.NonGeneric.Deserialize(type, ms); } default: return inner.Deserialize(item); } }
public bool Equals(CacheItem obj) { return(obj.flags == flags && obj.data.Equals(data)); }
object ITranscoder.Deserialize(CacheItem item) { if (item.Data == null || item.Data.Array == null) return null; if (item.Flags == RawDataFlag) { ArraySegment<byte> tmp = item.Data; if (tmp.Count == tmp.Array.Length) return tmp.Array; // we should never arrive here, but it's better to be safe than sorry byte[] retval = new byte[tmp.Count]; Array.Copy(tmp.Array, tmp.Offset, retval, 0, tmp.Count); return retval; } TypeCode code = (TypeCode)(item.Flags & 0x00ff); byte[] data = item.Data.Array; int offset = item.Data.Offset; int count = item.Data.Count; switch (code) { // 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-memcachedClient data management as well // // however we store 'null' as Empty + an empty array, // so this must special-cased for compatibilty with // earlier versions. we introduced DBNull as null marker in emc2.6 case TypeCode.Empty: return (data == null || count == 0) ? null : Encoding.UTF8.GetString(data, offset, count); case TypeCode.DBNull: return null; case TypeCode.String: return Encoding.UTF8.GetString(data, offset, count); case TypeCode.Boolean: return BitConverter.ToBoolean(data, offset); case TypeCode.Int16: return BitConverter.ToInt16(data, offset); case TypeCode.Int32: return BitConverter.ToInt32(data, offset); case TypeCode.Int64: return BitConverter.ToInt64(data, offset); case TypeCode.UInt16: return BitConverter.ToUInt16(data, offset); case TypeCode.UInt32: return BitConverter.ToUInt32(data, offset); case TypeCode.UInt64: return BitConverter.ToUInt64(data, offset); case TypeCode.Char: return BitConverter.ToChar(data, offset); case TypeCode.DateTime: return DateTime.FromBinary(BitConverter.ToInt64(data, offset)); case TypeCode.Double: return BitConverter.ToDouble(data, offset); case TypeCode.Single: return BitConverter.ToSingle(data, offset); case TypeCode.Object: using (MemoryStream ms = new MemoryStream(data, offset, count)) { return new BinaryFormatter().Deserialize(ms); } default: throw new InvalidOperationException("Unknown TypeCode was returned: " + code); } }
public GetResponse(string key, ushort flags, ulong casValue, byte[] data, int offset, int count) { this.Key = key; this.CasValue = casValue; this.Item = new CacheItem(flags, new ArraySegment<byte>(data, offset, count)); }
object ITranscoder.Deserialize(CacheItem item) { if (item.Data == null || item.Data.Array == null) return null; if (item.Flags == RawDataFlag) { ArraySegment<byte> tmp = item.Data; if (tmp.Count == tmp.Array.Length) return tmp.Array; // we should never arrive here, but it's better to be safe than sorry byte[] retval = new byte[tmp.Count]; Array.Copy(tmp.Array, tmp.Offset, retval, 0, tmp.Count); return retval; } TypeCode code = (TypeCode)(item.Flags & 0x00ff); byte[] data = item.Data.Array; int offset = item.Data.Offset; int count = item.Data.Count; switch (code) { // 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 // // however we store 'null' as Empty + an empty array, // so this must special-cased for compatibilty with // earlier versions. we introduced DBNull as null marker in emc2.6 case TypeCode.Empty: return (data == null || count == 0) ? null : Encoding.UTF8.GetString(data, offset, count); case TypeCode.DBNull: return null; case TypeCode.String: return Encoding.UTF8.GetString(data, offset, count); case TypeCode.Boolean: return BitConverter.ToBoolean(data, offset); case TypeCode.Int16: return BitConverter.ToInt16(data, offset); case TypeCode.Int32: return BitConverter.ToInt32(data, offset); case TypeCode.Int64: return BitConverter.ToInt64(data, offset); case TypeCode.UInt16: return BitConverter.ToUInt16(data, offset); case TypeCode.UInt32: return BitConverter.ToUInt32(data, offset); case TypeCode.UInt64: return BitConverter.ToUInt64(data, offset); case TypeCode.Char: return BitConverter.ToChar(data, offset); case TypeCode.DateTime: return DateTime.FromBinary(BitConverter.ToInt64(data, offset)); case TypeCode.Double: return BitConverter.ToDouble(data, offset); case TypeCode.Single: return BitConverter.ToSingle(data, offset); case TypeCode.Object: using (MemoryStream ms = new MemoryStream(data, offset, count)) { return new BinaryFormatter().Deserialize(ms); } default: throw new InvalidOperationException("Unknown TypeCode was returned: " + code); } }
protected virtual object Deserialize(CacheItem item) { if (item.Data.Array == null) { return(null); } if (item.Flags == RawDataFlag) { var tmp = item.Data; if (tmp.Count == tmp.Array.Length) { return(tmp.Array); } // we should never arrive here, but it's better to be safe than sorry var retval = new byte[tmp.Count]; Array.Copy(tmp.Array, tmp.Offset, retval, 0, tmp.Count); return(retval); } var code = (TypeCode)(item.Flags & 0xff); var data = item.Data; switch (code) { // 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 // // however we store 'null' as Empty + an empty array, // so this must special-cased for compatibilty with // earlier versions. we introduced DBNull as null marker in emc2.6 case TypeCode.Empty: return((data.Array == null || data.Count == 0) ? null : DeserializeString(data)); case TypeCode.DBNull: return(null); case TypeCode.String: return(this.DeserializeString(data)); case TypeCode.Boolean: return(this.DeserializeBoolean(data)); case TypeCode.Int16: return(this.DeserializeInt16(data)); case TypeCode.Int32: return(this.DeserializeInt32(data)); case TypeCode.Int64: return(this.DeserializeInt64(data)); case TypeCode.UInt16: return(this.DeserializeUInt16(data)); case TypeCode.UInt32: return(this.DeserializeUInt32(data)); case TypeCode.UInt64: return(this.DeserializeUInt64(data)); case TypeCode.Char: return(this.DeserializeChar(data)); case TypeCode.DateTime: return(this.DeserializeDateTime(data)); case TypeCode.Double: return(this.DeserializeDouble(data)); case TypeCode.Single: return(this.DeserializeSingle(data)); case TypeCode.Byte: return(this.DeserializeByte(data)); case TypeCode.SByte: return(this.DeserializeSByte(data)); // backward compatibility // earlier versions serialized decimals with TypeCode.Decimal // even though they were saved by BinaryFormatter case TypeCode.Decimal: case TypeCode.Object: return(this.DeserializeObject(data)); default: throw new InvalidOperationException("Unknown TypeCode was returned: " + code); } }
object ITranscoder.Deserialize(CacheItem item) { if (item.Flag == RawDataFlag) { ArraySegment<byte> tmp = item.Data; if (tmp.Count == tmp.Array.Length) return tmp.Array; // we should never arrive here, but it's better to be safe than sorry byte[] retval = new byte[tmp.Count]; Array.Copy(tmp.Array, tmp.Offset, retval, 0, tmp.Count); return retval; } TypeCode code = (TypeCode)(item.Flag & 0x00ff); if (code == TypeCode.Empty) return null; byte[] data = item.Data.Array; int offset = item.Data.Offset; int count = item.Data.Count; switch (code) { case TypeCode.String: return Encoding.UTF8.GetString(data, offset, count); case TypeCode.Boolean: return BitConverter.ToBoolean(data, offset); case TypeCode.Int16: return BitConverter.ToInt16(data, offset); case TypeCode.Int32: return BitConverter.ToInt32(data, offset); case TypeCode.Int64: return BitConverter.ToInt64(data, offset); case TypeCode.UInt16: return BitConverter.ToUInt16(data, offset); case TypeCode.UInt32: return BitConverter.ToUInt32(data, offset); case TypeCode.UInt64: return BitConverter.ToUInt64(data, offset); case TypeCode.Char: return BitConverter.ToChar(data, offset); case TypeCode.DateTime: return DateTime.FromBinary(BitConverter.ToInt64(data, offset)); case TypeCode.Double: return BitConverter.ToDouble(data, offset); case TypeCode.Single: return BitConverter.ToSingle(data, offset); case TypeCode.Object: using (MemoryStream ms = new MemoryStream(data, offset, count)) { return new BinaryFormatter().Deserialize(ms); } default: throw new InvalidOperationException("Unknown TypeCode was returned: " + code); } }
public bool Equals(CacheItem obj) { return obj.flags == flags && obj.segment.Equals(segment); }
object ITranscoder.Deserialize(CacheItem item) { return(this.Deserialize(item)); }
public VBStore(VBucketNodeLocator locator, StoreMode mode, string key, CacheItem value, uint expires) : base(mode, key, value, expires) { this.locator = locator; }
object ITranscoder.Deserialize(CacheItem item) { switch (item.Flags) { case ProtoIdentifier: var segment = item.Data; byte[] raw = segment.Array; int count = segment.Count, offset = segment.Offset; Type type = ReadType(raw, ref offset, ref count); using (var ms = new MemoryStream(raw, offset, count)) { Interlocked.Increment(ref deserializedCount); return model.Deserialize(ms, null, type); } default: return inner.Deserialize(item); } }
object ITranscoder.Deserialize(CacheItem item) => this.Deserialize(item);
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); } }
object ITranscoder.Deserialize(CacheItem item) { if (item.Flag == RawDataFlag) { ArraySegment <byte> tmp = item.Data; if (tmp.Count == tmp.Array.Length) { return(tmp.Array); } // we should never arrive here, but it's better to be safe than sorry byte[] retval = new byte[tmp.Count]; Array.Copy(tmp.Array, tmp.Offset, retval, 0, tmp.Count); return(retval); } TypeCode code = (TypeCode)(item.Flag & 0x00ff); if (code == TypeCode.Empty) { return(null); } byte[] data = item.Data.Array; int offset = item.Data.Offset; int count = item.Data.Count; switch (code) { case TypeCode.String: return(Encoding.UTF8.GetString(data, offset, count)); case TypeCode.Boolean: return(BitConverter.ToBoolean(data, offset)); case TypeCode.Int16: return(BitConverter.ToInt16(data, offset)); case TypeCode.Int32: return(BitConverter.ToInt32(data, offset)); case TypeCode.Int64: return(BitConverter.ToInt64(data, offset)); case TypeCode.UInt16: return(BitConverter.ToUInt64(data, offset)); case TypeCode.UInt32: return(BitConverter.ToUInt32(data, offset)); case TypeCode.UInt64: return(BitConverter.ToUInt64(data, offset)); case TypeCode.Char: return(BitConverter.ToChar(data, offset)); case TypeCode.DateTime: return(DateTime.FromBinary(BitConverter.ToInt64(data, offset))); case TypeCode.Double: return(BitConverter.ToDouble(data, offset)); case TypeCode.Single: return(BitConverter.ToSingle(data, offset)); case TypeCode.Object: using (MemoryStream ms = new MemoryStream(data, offset, count)) { return(new BinaryFormatter().Deserialize(ms)); } default: throw new InvalidOperationException("Unknown TypeCode was returned: " + code); } }
IStoreOperation IOperationFactory.Store(StoreMode mode, string key, CacheItem value, uint expires, ulong cas) { return new VBStore(locator, mode, key, value, expires) { Cas = cas }; }
public IStoreOperation Store(StoreMode mode, Key key, CacheItem value, uint expires, ulong cas) { throw new NotImplementedException(); }
object ITranscoder.Deserialize(CacheItem item) { return this.Deserialize(item); }
public object Deserialize(CacheItem item) { throw new NotImplementedException(); }