コード例 #1
0
ファイル: AzusaDexTimeline.cs プロジェクト: feyris-tan/azusa
        public static AzusaDexTimeline LoadFrom(FileInfo fi)
        {
            FileStream       fs     = fi.OpenRead();
            AzusaDexTimeline result = LoadFrom(fs);

            fs.Close();
            return(result);
        }
コード例 #2
0
ファイル: AzusaDexTimeline.cs プロジェクト: feyris-tan/azusa
        public static AzusaDexTimeline LoadFrom(Stream str)
        {
            if (xs == null)
            {
                xs = new XmlSerializer(typeof(AzusaDexTimeline));
            }

            AzusaDexTimeline result = (AzusaDexTimeline)xs.Deserialize(str);

            return(result);
        }
コード例 #3
0
ファイル: AzusaDexTimeline.cs プロジェクト: feyris-tan/azusa
        public static AzusaDexTimeline LoadFrom(DexcomDevice dd)
        {
            AzusaDexTimeline result = new AzusaDexTimeline();

            result.Timestamp = dd.ReadRTC();
            PartitionInfo pi = dd.ReadDatabaseParitionInfo();

            for (int i = 0; i < pi.Partition.Length; i++)
            {
                DatabasePageRange dpr = dd.ReadDatabasePageRange(pi.Partition[i]);
                if (dpr.Start == -1)
                {
                    continue;
                }
                for (int j = dpr.Start; j < dpr.End; j++)
                {
                    DatabasePage page = dd.ReadDatabasePage(pi.Partition[i], j);
                    for (int k = 0; k < page.Record.Length; k++)
                    {
                        switch (page.RecordType)
                        {
                        case RecordType.SensorData:
                            SensorData sd = page.Record[k] as SensorData;
                            result[sd.DisplayTime].Rssi             = sd.Rssi;
                            result[sd.DisplayTime].SensorFiltered   = sd.Filtered;
                            result[sd.DisplayTime].SensorUnfiltered = sd.Unfiltered;
                            break;

                        case RecordType.EgvData:
                            EGVRecord egv = page.Record[k] as EGVRecord;
                            if (egv.SpecialGlucoseValue == null)
                            {
                                result[egv.DisplayTime].Glucose = egv.Glucose;
                            }
                            else
                            {
                                result[egv.DisplayTime].SpecialGlucoseValue = egv.SpecialGlucoseValue;
                            }
                            result[egv.DisplayTime].TrendArrow = egv.TrendArrow;
                            break;

                        case RecordType.InsertionTime:
                            InsertionTime it = page.Record[k] as InsertionTime;
                            result[it.DisplayTime].SessionState = it.SessionState;
                            break;

                        case RecordType.MeterData:
                            MeterData md = page.Record[k] as MeterData;
                            result[md.DisplayTime].MeterGlucose = md.MeterGlucose;
                            break;

                        case RecordType.UserEventData:
                            UserEventData ued = page.Record[k] as UserEventData;
                            result[ued.DisplayTime2].EventType = ued.EventType;
                            switch (ued.EventType)
                            {
                            case EventType.Carbs:
                                result[ued.DisplayTime2].Carbs = ued.EventValue;
                                break;

                            case EventType.Insulin:
                                result[ued.DisplayTime2].Insulin = ued.EventValue;
                                break;

                            default:
                                result[ued.DisplayTime2].HealthEvent   = ued.HealthEvent;
                                result[ued.DisplayTime2].ExerciseEvent = ued.ExerciseEvent;
                                break;
                            }
                            break;

                        case RecordType.ManufacturingData:
                            ManufacturingParameters mp = page.Record[k] as ManufacturingParameters;
                            result[mp.DisplayTime].ManufacturingParameters = mp;
                            break;

                        case RecordType.FirmwareParameterData:
                            FirmwareParameterData fpd = page.Record[k] as FirmwareParameterData;
                            result[fpd.DisplayTime].FirmwareParameters = fpd.FPR;
                            break;

                        case RecordType.PcSoftwareParameter:
                            PcSoftwareParameter pcp = page.Record[k] as PcSoftwareParameter;
                            result[pcp.DisplayTime].PcSoftwareParameter = pcp;
                            break;

                        case RecordType.CalSet:
                        case RecordType.ReceiverLogData:
                        case RecordType.UserSettingData:
                        case RecordType.Deviation:
                            break;

                        default:
                            throw new NotImplementedException(page.RecordType.ToString());
                        }
                    }
                }
            }

            result.Order();
            return(result);
        }