public override void WriteValue(Stream stream, object value, SerializerSession session)
{
if (value == null)
{
stream.WriteInt32(-1);
}
else
{
var type = (Type) value;
int existingId;
if (session.Serializer.Options.PreserveObjectReferences && session.TryGetObjectId(type, out existingId))
{
ObjectReferenceSerializer.Instance.WriteManifest(stream, null, session);
ObjectReferenceSerializer.Instance.WriteValue(stream, existingId, session);
}
else
{
//type was not written before, add it to the tacked object list
var name = type.GetShortAssemblyQualifiedName();
if (session.Serializer.Options.PreserveObjectReferences)
{
session.TrackSerializedObject(type);
}
// ReSharper disable once PossibleNullReferenceException
// ReSharper disable once AssignNullToNotNullAttribute
var bytes = Encoding.UTF8.GetBytes(name);
stream.WriteLengthEncodedByteArray(bytes);
}
}
}
public override object ReadValue(Stream stream, SerializerSession session)
{
var size = sizeof(UInt16);
var buffer = session.GetBuffer(size);
stream.Read(buffer, 0, size);
return BitConverter.ToUInt16(buffer, 0);
}
public override void WriteValue(Stream stream, object value, SerializerSession session)
{
if (value == null)
{
StringSerializer.WriteValueImpl(stream,null,session);
}
else
{
var type = (Type) value;
int existingId;
if (session.Serializer.Options.PreserveObjectReferences && session.TryGetObjectId(type, out existingId))
{
ObjectReferenceSerializer.Instance.WriteManifest(stream, session);
ObjectReferenceSerializer.Instance.WriteValue(stream, existingId, session);
}
else
{
if (session.Serializer.Options.PreserveObjectReferences)
{
session.TrackSerializedObject(type);
}
//type was not written before, add it to the tacked object list
var name = type.GetShortAssemblyQualifiedName();
StringSerializer.WriteValueImpl(stream, name, session);
}
}
}
public override void WriteValue(Stream stream, object value, SerializerSession session)
{
//null = 0
// [0]
//length < 255 gives length + 1 as a single byte + payload
// [B length+1] [Payload]
//others gives 254 + int32 length + payload
// [B 254] [I Length] [Payload]
if (value == null)
{
stream.WriteByte(0);
}
else
{
var bytes = Encoding.UTF8.GetBytes((string) value);
if (bytes.Length < 255)
{
stream.WriteByte((byte)(bytes.Length+1));
stream.Write(bytes, 0, bytes.Length);
}
else
{
stream.WriteByte(254);
stream.WriteInt32(bytes.Length);
stream.Write(bytes,0,bytes.Length);
}
}
}
public override void WriteValue(Stream stream, object value, SerializerSession session)
{
var data = decimal.GetBits((decimal) value);
stream.WriteInt32(data[0]);
stream.WriteInt32(data[1]);
stream.WriteInt32(data[2]);
stream.WriteInt32(data[3]);
}
public override object ReadValue(Stream stream, SerializerSession session)
{
var size = sizeof (long);
var buffer = session.GetBuffer(size);
stream.Read(buffer, 0, size);
var ticks = BitConverter.ToInt64(buffer, 0);
return new DateTime(ticks);
}
public override void WriteValue(Stream stream, object value, SerializerSession session)
{
var bytes = session.GetBuffer(Int32Serializer.Size);
var data = decimal.GetBits((decimal) value);
Int32Serializer.WriteValueImpl(stream, data[0], bytes);
Int32Serializer.WriteValueImpl(stream, data[1], bytes);
Int32Serializer.WriteValueImpl(stream, data[2], bytes);
Int32Serializer.WriteValueImpl(stream, data[3], bytes);
}
public override object ReadValue(Stream stream, SerializerSession session)
{
var length = (int) Int32Serializer.Instance.ReadValue(stream, session);
if (length == -1)
return null;
var buffer = session.GetBuffer(length);
stream.Read(buffer, 0, length);
var res = Encoding.UTF8.GetString(buffer, 0, length);
return res;
}
public override void WriteValue(Stream stream, object value, SerializerSession session)
{
if (value == null)
{
stream.WriteInt32(-1);
}
else
{
var bytes = Encoding.UTF8.GetBytes((string) value);
stream.WriteLengthEncodedByteArray(bytes);
}
}
public override object ReadValue(Stream stream, SerializerSession session)
{
var length = stream.ReadInt32(session);
var array = Array.CreateInstance(_elementType, length); //create the array
for (var i = 0; i < length; i++)
{
var value = stream.ReadObject(session);
array.SetValue(value, i); //set the element value
}
return array;
}
public override void WriteManifest(Stream stream, Type type, SerializerSession session)
{
if (session.ShouldWriteTypeManifest(type))
{
stream.WriteByte(Manifest);
}
else
{
var typeIdentifier = session.GetTypeIdentifier(type);
stream.Write(new[] { ObjectSerializer.ManifestIndex });
stream.WriteUInt16((ushort) typeIdentifier);
}
}
public override void WriteValue(Stream stream, object arr, SerializerSession session)
{
var array = arr as Array;
var elementSerializer = session.Serializer.GetSerializerByType(_elementType);
stream.WriteInt32(array.Length);
var preserveObjectReferences = session.Serializer.Options.PreserveObjectReferences;
for (var i = 0; i < array.Length; i++) //write the elements
{
var value = array.GetValue(i);
stream.WriteObject(value, _elementType, elementSerializer, preserveObjectReferences, session);
}
}
public override void WriteManifest(Stream stream, SerializerSession session)
{
ushort typeIdentifier;
if (session.ShouldWriteTypeManifest(TypeEx.RuntimeType,out typeIdentifier))
{
stream.WriteByte(Manifest);
}
else
{
stream.Write(new[] { ObjectSerializer.ManifestIndex });
UInt16Serializer.WriteValueImpl(stream,typeIdentifier,session);
}
}
public override void WriteValue(Stream stream, object value, SerializerSession session)
{
var array = value as Array;
var elementType = value.GetType().GetElementType();
var elementSerializer = session.Serializer.GetSerializerByType(elementType);
elementSerializer.WriteManifest(stream, elementType, session); //write array element type
stream.WriteInt32(array.Length);
for (var i = 0; i < array.Length; i++) //write the elements
{
var elementValue = array.GetValue(i);
elementSerializer.WriteValue(stream, elementValue, session);
}
}
public override void WriteValue(Stream stream, object value, SerializerSession session)
{
if (value == null)
{
stream.WriteInt32(-1);
}
else
{
var type = (Type) value;
var name = type.AssemblyQualifiedName;
var bytes = Encoding.UTF8.GetBytes(name);
stream.WriteLengthEncodedByteArray(bytes);
}
}
public override object ReadValue(Stream stream, SerializerSession session)
{
var parts = new[]
{
(int) Int32Serializer.Instance.ReadValue(stream, session),
(int) Int32Serializer.Instance.ReadValue(stream, session),
(int) Int32Serializer.Instance.ReadValue(stream, session),
(int) Int32Serializer.Instance.ReadValue(stream, session)
};
var sign = (parts[3] & 0x80000000) != 0;
var scale = (byte) ((parts[3] >> 16) & 0x7F);
var newValue = new decimal(parts[0], parts[1], parts[2], sign, scale);
return newValue;
}
public override object ReadValue(Stream stream, SerializerSession session)
{
var elementSerializer = session.Serializer.GetDeserializerByManifest(stream, session);
//read the element type
var elementType = elementSerializer.GetElementType();
//get the element type serializer
var length = (int) Int32Serializer.Instance.ReadValue(stream, session); //read the array length
var array = Array.CreateInstance(elementType, length); //create the array
for (var i = 0; i < length; i++)
{
var value = elementSerializer.ReadValue(stream, session); //read the element value
array.SetValue(value, i); //set the element value
}
return array;
}
public void SaveSession(SerializerSession session)
{
this.AddUpdateSessionToDevice(session);
using (CgmContext cgmContext = new CgmContext())
{
var settings = cgmContext.GetConfiguration <PumpSettings>();
if (settings != null)
{
cgmContext.UpdateConfiguration <PumpSettings>(session.PumpSettings);
}
else
{
cgmContext.AddConfiguration <PumpSettings>(session.PumpSettings);
}
if (session.PumpDataHistory != null)
{
var all = session.PumpDataHistory.PumpEvents.Where(e => e.EventType == EventTypeEnum.PLGM_CONTROLLER_STATE).ToList();
all.ForEach(e => session.PumpDataHistory.PumpEvents.Remove(e));
if (session.PumpDataHistory.PumpEvents.Count > 0)
{
this.Sync(session.PumpDataHistory.PumpEvents.Select(e => new History(e)).ToList(), (int)HistoryDataTypeEnum.Pump);
}
if (session.PumpDataHistory.SensorEvents.Count > 0)
{
this.Sync(session.PumpDataHistory.SensorEvents.Select(e => new History(e)).ToList(), (int)HistoryDataTypeEnum.Sensor);
}
SaveLastReadHistoryInConfiguration();
}
if (session.Status != null && session.Status.Count > 0 && session.PumpTime.PumpDateTime.HasValue)
{
foreach (var item in session.Status)
{
DeviceStatus deviceStatus = new DeviceStatus();
deviceStatus.DeviceStatusKey = session.PumpTime.Rtc.GetInt32(0).ToString();
deviceStatus.DeviceStatusBytes = item.BytesAsString;
if (cgmContext.DeviceStatus.FirstOrDefault(e => e.DeviceStatusKey == deviceStatus.DeviceStatusKey) != null)
{
cgmContext.DeviceStatus.Add(deviceStatus);
cgmContext.SaveChanges();
}
}
}
}
}
public override object ReadValue(Stream stream, SerializerSession session)
{
var length = (int)Int32Serializer.Instance.ReadValue(stream, session);
if (length == -1)
{
return(null);
}
var buffer = session.GetBuffer(length);
stream.Read(buffer, 0, length);
var res = Encoding.UTF8.GetString(buffer, 0, length);
return(res);
}
public override object ReadValue(Stream stream, SerializerSession session)
{
var elementSerializer = session.Serializer.GetDeserializerByManifest(stream, session);
//read the element type
var elementType = elementSerializer.GetElementType();
//get the element type serializer
var length = (int)Int32Serializer.Instance.ReadValue(stream, session); //read the array length
var array = Array.CreateInstance(elementType, length); //create the array
for (var i = 0; i < length; i++)
{
var value = elementSerializer.ReadValue(stream, session); //read the element value
array.SetValue(value, i); //set the element value
}
return(array);
}
public static object ReadValue(ref Reader reader, SerializerSession session, Field field)
{
if (field.WireType == WireType.Reference)
{
return(ReferenceCodec.ReadReference <object>(ref reader, session, field));
}
if (field.FieldType == ObjectType || field.FieldType == null)
{
reader.ReadVarUInt32();
return(new object());
}
var specificSerializer = session.CodecProvider.GetCodec(field.FieldType);
return(specificSerializer.ReadValue(ref reader, session, field));
}
public override object ReadValue(Stream stream, SerializerSession session)
{
var parts = new[]
{
(int)Int32Serializer.Instance.ReadValue(stream, session),
(int)Int32Serializer.Instance.ReadValue(stream, session),
(int)Int32Serializer.Instance.ReadValue(stream, session),
(int)Int32Serializer.Instance.ReadValue(stream, session)
};
var sign = (parts[3] & 0x80000000) != 0;
var scale = (byte)((parts[3] >> 16) & 0x7F);
var newValue = new decimal(parts[0], parts[1], parts[2], sign, scale);
return(newValue);
}
public static byte[] ReadValue(ref Reader reader, SerializerSession session, Field field)
{
if (field.WireType == WireType.Reference)
{
return(ReferenceCodec.ReadReference <byte[]>(ref reader, session, field));
}
if (field.WireType != WireType.LengthPrefixed)
{
ThrowUnsupportedWireTypeException(field);
}
var length = reader.ReadVarUInt32();
var result = reader.ReadBytes(length);
ReferenceCodec.RecordObject(session, result);
return(result);
}
public override void WriteManifest(Stream stream, SerializerSession session)
{
if (session.ShouldWriteTypeManifest(Type, out var typeIdentifier))
{
session.TrackSerializedType(Type);
var manifestToWrite = _manifest;
stream.Write(manifestToWrite);
}
else
{
stream.WriteByte(ManifestIndex);
UInt16Serializer.WriteValueImpl(stream, typeIdentifier, session);
}
}
public static Field ReadFieldHeader(this Reader reader, SerializerSession session)
{
var field = default(Field);
field.Tag = reader.ReadByte();
if (field.HasExtendedFieldId)
{
field.FieldIdDelta = reader.ReadVarUInt32();
}
if (field.IsSchemaTypeValid)
{
field.FieldType = reader.ReadType(session, field.SchemaType);
}
return(field);
}
byte[] IFieldCodec <byte[]> .ReadValue(Reader reader, SerializerSession session, Field field)
{
if (field.WireType == WireType.Reference)
{
return(ReferenceCodec.ReadReference <byte[]>(reader, session, field, this.codecProvider));
}
if (field.WireType != WireType.LengthPrefixed)
{
ThrowUnsupportedWireTypeException(field);
}
var length = reader.ReadVarUInt32();
var result = reader.ReadBytes((int)length);
ReferenceCodec.RecordObject(session, result);
return(result);
}
private async void UpdatedSession(SerializerSession session)
{
await CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(CoreDispatcherPriority.Normal,
() =>
{
if (session.Status.Count > 0)
{
//var entry = session.Status.Last();
//PumpStatusMessages.Insert(0, entry);
foreach (var item in session.Status)
{
PumpStatusMessages.Insert(0, item);
}
}
});
}
/// <summary>
/// Consumes a tag-delimited field.
/// </summary>
private static void ConsumeTagDelimitedField(Reader reader, SerializerSession session)
{
while (true)
{
var field = reader.ReadFieldHeader(session);
if (field.IsEndObject)
{
break;
}
if (field.IsEndBaseFields)
{
continue;
}
reader.ConsumeUnknownField(session, field);
}
}
public static bool TryWriteReferenceField(
ref Writer writer,
SerializerSession session,
uint fieldId,
Type expectedType,
object value)
{
if (!session.ReferencedObjects.GetOrAddReference(value, out var reference))
{
return(false);
}
writer.WriteFieldHeader(session, fieldId, expectedType, value?.GetType(), WireType.Reference);
writer.WriteVarInt(reference);
return(true);
}
public void SaveSession(SerializerSession session)
{
List <CommunicationMessage> msgs = new List <CommunicationMessage>();
foreach (var handler in session.PumpDataHistory.MultiPacketHandlers)
{
foreach (var item in handler.Segments)
{
foreach (var eve in item.Events)
{
CommunicationMessageTemp msg = new CommunicationMessageTemp();
msg.MessageKey = $"{handler.ReadInfoResponse.HistoryDataTypeRaw} - {BitConverter.ToString(eve.AllBytes)}";
msg.MessageDateTime = eve.Timestamp.Value;
msg.MessageType = handler.ReadInfoResponse.HistoryDataType.ToString();
msg.MessageSubType = eve.EventType.ToString();
msg.Message = BitConverter.ToString(eve.AllBytes);
if (eve.EventType == EventTypeEnum.ALARM_NOTIFICATION)
{
msg.NotificationStatus = 1;
}
if (eve.EventType == EventTypeEnum.SENSOR_GLUCOSE_READINGS_EXTENDED
||
eve.EventType == EventTypeEnum.BOLUS_WIZARD_ESTIMATE
||
eve.EventType == EventTypeEnum.ALARM_NOTIFICATION
||
eve.EventType == EventTypeEnum.GLUCOSE_SENSOR_CHANGE
)
{
msg.NightScoutStatus = 1;
}
msgs.Add(msg);
}
}
}
//this._uow.Connection.DeleteAll<CommunicationMessageTemp>();
//this._uow.Connection.InsertAll(msgs,false);
var listToAdd = this._uow.Connection.Query <CommunicationMessage>("select * from CommunicationMessage right outer join CommunicationMessageTemp on CommunicationMessage.MessageKey=CommunicationMessageTemp.MessageKey where CommunicationMessage.MessageKey is null", null);
this._uow.Connection.DeleteAll <CommunicationMessageTemp>();
this._uow.Connection.InsertAll(listToAdd);
}
public void OnSerialization(List <byte> bytes, SerializerSession settings)
{
if (bytes.Count > 32)
{
//medtronic length
bytes[33] = (byte)(bytes.Count - 38);
}
if (bytes.Count > 37)
{
if (bytes[37] == 0x00)
{
var temp = bytes.GetRange(5, bytes.Count - 5).ToArray();
bytes[37] = temp.OneByteSum();
}
}
}
public void OnDeserialization(byte[] bytes, SerializerSession settings)
{
this.AllBytes = bytes;
this.AllBytesAsString = BitConverter.ToString(bytes);
Reader = new BayerStickInfoReader(this.Value);
this.ModelNumber = Reader.DeviceVersion.Name;
this.RFID = Reader.DeviceVersion.RFID;
this.SerialNumberFull = Reader.DeviceVersion.SerialNum;
this.SerialNumber = Reader.DeviceVersion.SerialNumSmall;
this.HMACbyte = Reader.HMACbyte;
if (settings != null)
{
settings.SessionDevice.Device = this;
}
}
private List <BasePumpEvent> Convert(List <History> histories, SerializerSession session)
{
List <BasePumpEvent> eventsToHandle = new List <BasePumpEvent>();
if (histories.Count > 0)
{
Serializer serializer = new Serializer(session);
foreach (var item in histories)
{
var pumpevent = serializer.Deserialize <BasePumpEvent>(item.HistoryBytes.GetBytes());
pumpevent.HistoryDataType = item.HistoryDataType;
eventsToHandle.Add(pumpevent);
}
}
return(eventsToHandle);
}
//public TransferToWeb()
//{
// string configurationFile = $"configurations/WebDataTransferConfiguration.json";
// Configuration = JsonConvert.DeserializeObject<WebDataTransferConfiguration>(File.ReadAllText(configurationFile));
//}
public async Task ExecuteTask(SerializerSession session, CancellationToken cancelToken)
{
//var config= session.GetConfiguration<WebDataTransferConfiguration>();
var dto = session.GetSessionDTO();
string key = Configuration.ApiKey.Sha1Digest();
IFormatter formatter = new BinaryFormatter();
ActionOfStreamContent content = new ActionOfStreamContent((stream) => formatter.Serialize(stream, dto));
content.Headers.Add("API-SECRET", Configuration.ApiKey);
using (var client = new HttpClient())
{
client.BaseAddress = new Uri(Configuration.Url);
var result = client.PostAsync("api/session", content).Result;
}
}
public static Guid ReadValue(ref Reader reader, SerializerSession session, Field field)
{
ReferenceCodec.MarkValueField(session);
#if NETCOREAPP2_1
if (reader.TryReadBytes(Width, out var readOnly))
{
return(new Guid(readOnly));
}
// TODO: stackalloc
Span <byte> bytes = new byte[Width];
reader.ReadBytes(in bytes);
return(new Guid(bytes));
#else
return(new Guid(reader.ReadBytes(Width)));
#endif
}
private void RunBehaviors(SerializerSession session)
{
var behaviors = CommonServiceLocator.ServiceLocator.Current.GetInstance <ISessionBehaviors>();
var _token = new CancellationToken();
foreach (var item in behaviors.SessionBehaviors)
{
try
{
item.ExecuteTask(session, _token).TimeoutAfter(15000);
}
catch (Exception ex)
{
throw;
}
}
}
public override void WriteManifest(Stream stream, SerializerSession session)
{
if (session.ShouldWriteTypeManifest(Type, out ushort typeIdentifier))
{
session.TrackSerializedType(Type);
var manifestToWrite = session.Serializer.Options.VersionTolerance
? _manifestWithVersionInfo
: _manifest;
stream.Write(manifestToWrite);
}
else
{
stream.WriteByte(ManifestIndex);
UInt16Serializer.WriteValueImpl(stream, typeIdentifier, session);
}
}
public void OnDeserialization(byte[] bytes, SerializerSession settings)
{
List <byte> list = new List <byte>();
list.AddRange(bytes);
var data = list.GetRange(0, list.Count - 2);
var Crc = list.GetRange(list.Count - 2, 2).ToArray();
var crc = data.ToArray().GetCrc16citt() & 0xffff;
var ch = Crc.GetInt16(0) & 0xffff;
this.IsCrcCorrect = crc == ch;
if (IsCrcCorrect)
{
}
else
{
}
}
public void OnDeserialization(byte[] bytes, SerializerSession settings)
{
//settings.DeviceString = this;
//calculate End....
for (int i = 0; i < BolusWizardSensitivityFactorDetails.Count; i++)
{
if (i == BolusWizardSensitivityFactorDetails.Count - 1)
{
//last one
BolusWizardSensitivityFactorDetails[i].End = new TimeSpan(24, 0, 0);
}
else
{
BolusWizardSensitivityFactorDetails[i].End = BolusWizardSensitivityFactorDetails[i + 1].Start;
}
}
settings.BolusWizardSensitivityFactors = this;
}
public static object ReadReference(ref Reader reader, SerializerSession session, Field field, Type expectedType)
{
var reference = reader.ReadVarUInt32();
if (!session.ReferencedObjects.TryGetReferencedObject(reference, out var value))
{
ThrowReferenceNotFound(expectedType, reference);
}
switch (value)
{
case UnknownFieldMarker marker:
return(DeserializeFromMarker(ref reader, session, field, marker, reference, expectedType));
default:
return(value);
}
}
public static void WriteField(ref Writer writer, SerializerSession session, uint fieldIdDelta, Type expectedType, object value)
{
var fieldType = value?.GetType();
if (fieldType == null || fieldType == ObjectType)
{
if (ReferenceCodec.TryWriteReferenceField(ref writer, session, fieldIdDelta, expectedType, value))
{
return;
}
writer.WriteFieldHeader(session, fieldIdDelta, expectedType, ObjectType, WireType.LengthPrefixed);
writer.WriteVarInt((uint)0);
}
var specificSerializer = session.CodecProvider.GetCodec(fieldType);
specificSerializer.WriteField(ref writer, session, fieldIdDelta, expectedType, value);
}
public void SaveHistory(SerializerSession session)
{
if (session.PumpDataHistory != null)
{
if (session.PumpDataHistory.PumpEvents.Count > 0)
{
this.Sync(session.PumpDataHistory.PumpEvents.Select(e => new History(e)).ToList(), (int)HistoryDataTypeEnum.Pump);
}
if (session.PumpDataHistory.SensorEvents.Count > 0)
{
this.Sync(session.PumpDataHistory.SensorEvents.Select(e => new History(e)).ToList(), (int)HistoryDataTypeEnum.Sensor);
//var last = session.PumpDataHistory.SensorEvents.Last();
//session.Settings.LastRead.Add(new LastPumpRead() { DataType = (int)HistoryDataTypeEnum.Sensor, LastRtc = rtc });
}
SaveLastReadHistoryInSettings();
}
}
public void Start(IDevice device)
{
if (device == null)
{
throw new ArgumentException("No device found");
}
session = null;
_device = device;
Delay = TimeSpan.FromSeconds(_delayInSeconds);
_tokenSource = new CancellationTokenSource();
_token = _tokenSource.Token;
stateRepository = new SessionStateRepository();
session = new SerializerSession();
stateRepository.GetOrSetSessionAndSettings(session);
SetConfiguration();
SetUpTimer(DateTime.Now.AddSeconds(2));
}
public async Task StartCommunication(IDevice device, SerializerSession session, CancellationToken cancelToken)
{
int periode = 0;
_cancelToken = cancelToken;
Session = session;
_device = device;
if (TimeoutSeconds == 0)
{
TimeoutSeconds = session.Settings.TimeoutSeconds;
//Logger.LogInformation($"Timeout in Seconds: {TimeoutSeconds}");
}
if (_device.IsConnected)
{
var lists = this.GetRequestBytes();
StartTimer();
foreach (var item in lists)
{
Log(item.ToArray());
await _device.SendBytes(item.ToArray());
}
if (this.ExpectedResponses.Count > 0)
{
//wait for all responses or timeout for whole block.
while (this._running && _device.IsConnected)
{
periode += delay;
Task.Delay(delay).Wait();
if ((TimeoutSeconds * 1000) <= periode)
{
CommunicationError("Error: timeout");
return;
}
}
}
StopTimer();
}
}
public void WriteField(ref Writer writer, SerializerSession session, uint fieldIdDelta, Type expectedType, T[] value)
{
if (ReferenceCodec.TryWriteReferenceField(ref writer, session, fieldIdDelta, expectedType, value))
{
return;
}
writer.WriteFieldHeader(session, fieldIdDelta, expectedType, value.GetType(), WireType.TagDelimited);
Int32Codec.WriteField(ref writer, session, 0, typeof(int), value.Length);
var first = true;
foreach (var element in value)
{
this.fieldCodec.WriteField(ref writer, session, first ? 1U : 0, typeof(T), element);
first = false;
}
writer.WriteEndObject();
}
private static void WriteValues <T>(T[] array, Stream stream, ValueSerializer elementSerializer,
SerializerSession session)
{
Int32Serializer.WriteValueImpl(stream, array.Length, session);
if (typeof(T).IsFixedSizeType())
{
var size = typeof(T).GetTypeSize();
var result = new byte[array.Length * size];
Buffer.BlockCopy(array, 0, result, 0, result.Length);
stream.Write(result);
}
else
{
foreach (var value in array)
{
elementSerializer.WriteValue(stream, value, session);
}
}
}
public void OnDeserialization(byte[] bytes, SerializerSession settings)
{
settings.AddStatus(this);
this.AllBytes = bytes;
this.BytesAsString = BitConverter.ToString(bytes);
//if (this.SgvDateTime.HasValue)
//{
// this.LocalDateTimePumpDateTimeDifference = this.LocalDateTime.Subtract(this.SgvDateTime.Value);
//}
//this.ActiveInsulinRawConvert = this.ActiveInsulinRaw & 0x0000ffff;
//if (this.BolusEstModifiedByUser==1)
//{
// this.ActiveInsulinRawConvert += 0x0000ffff + 1;
//}
//errors where sgv >= 769
this.Sgv = this.SgvRaw & 0x0000ffff;
this.BolusWizardBGL = this.BolusWizardBGLRaw & 0x0000ffff;
}
public override void WriteManifest(Stream stream, SerializerSession session)
{
ushort typeIdentifier;
if (session.ShouldWriteTypeManifest(Type, out typeIdentifier))
{
session.TrackSerializedType(Type);
var manifestToWrite = session.Serializer.Options.VersionTolerance
? _manifestWithVersionInfo
: _manifest;
stream.Write(manifestToWrite);
}
else
{
stream.WriteByte(ManifestIndex);
UInt16Serializer.WriteValueImpl(stream, typeIdentifier, session);
}
}
public override object ReadValue(Stream stream, SerializerSession session)
{
throw new NotSupportedException();
}
public abstract void WriteManifest(Stream stream, Type type, SerializerSession session);
public override void WriteManifest(Stream stream, Type type, SerializerSession session)
{
stream.WriteByte(Manifest);
}
public abstract void WriteValue(Stream stream, object value, SerializerSession session);
public override object ReadValue(Stream stream, SerializerSession session)
{
return null;
}
public override void WriteValue(Stream stream, object value, SerializerSession session)
{
var bytes = (byte[]) value;
stream.WriteLengthEncodedByteArray(bytes);
}
public override object ReadValue(Stream stream, SerializerSession session)
{
return stream.ReadLengthEncodedByteArray(session);
}
public override void WriteValue(Stream stream, object value, SerializerSession session)
{
}
public override void WriteManifest(Stream stream, Type type, SerializerSession session)
{
// _surrogateSerializer.WriteManifest(stream, type, session);
}
public static void WriteObjectWithManifest(this Stream stream, object value, SerializerSession session)
{
if (value == null) //value is null
{
NullSerializer.Instance.WriteManifest(stream, session);
}
else
{
int existingId;
if (session.Serializer.Options.PreserveObjectReferences && session.TryGetObjectId(value, out existingId))
{
//write the serializer manifest
ObjectReferenceSerializer.Instance.WriteManifest(stream, session);
//write the object reference id
ObjectReferenceSerializer.Instance.WriteValue(stream, existingId, session);
}
else
{
var vType = value.GetType();
var s2 = session.Serializer.GetSerializerByType(vType);
s2.WriteManifest(stream, session);
s2.WriteValue(stream, value, session);
}
}
}
public override void WriteValue(Stream stream, object value, SerializerSession session)
{
var surrogateValue = _translator(value);
stream.WriteObject(surrogateValue, _type, _surrogateSerializer, session.Serializer.Options.PreserveObjectReferences, session);
}
public override void WriteValue(Stream stream, object value, SerializerSession session)
{
var bytes = BitConverter.GetBytes((long) value);
stream.Write(bytes);
}
