private bool Store(int observationId, Observation[] observations) { using (LiteDatabase db = new LiteDatabase(_liteDBPathName)) { var col = db.GetCollection <BufferedObservation>(_OBSBUF_NAME); foreach (Observation o in observations) { BufferedObservation bo = new BufferedObservation() { ObservationId = observationId, Timestamp = o.Timestamp, }; if (o.GetType() == typeof(BooleanObservation)) { bo.DataType = (int)DataType.Boolean; bo.Value = DataTypeStringConverter.FormatBoolean((o as BooleanObservation).Value); } else if (o.GetType() == typeof(DoubleObservation)) { bo.DataType = (int)DataType.Double; bo.Value = DataTypeStringConverter.FormatDouble((o as DoubleObservation).Value); } else if (o.GetType() == typeof(IntegerObservation)) { bo.DataType = (int)DataType.Integer; bo.Value = DataTypeStringConverter.FormatInteger((o as IntegerObservation).Value); } else if (o.GetType() == typeof(PositionObservation)) { bo.DataType = (int)DataType.Position; bo.Value = DataTypeStringConverter.FormatPosition((o as PositionObservation).Value); } else if (o.GetType() == typeof(StringObservation)) { bo.DataType = (int)DataType.String; bo.Value = (o as StringObservation).Value; } else if (o.GetType() == typeof(StatisticsObservation)) { bo.DataType = (int)DataType.Statistics; bo.Value = DataTypeStringConverter.FormatStatistics((o as StatisticsObservation).Value); } else { throw new ArgumentException("Unknown observation data type: " + o.GetType().ToString()); } col.Insert(bo); } return(true); } }
public override string ToString() { StringBuilder sb = new StringBuilder(); foreach (IdentifiedObservations io in Package.Observations) { foreach (Observation o in io.Observations) { string value; if (o is BooleanObservation) { value = DataTypeStringConverter.FormatBoolean(((BooleanObservation)(o)).Value); } else if (o is DoubleObservation) { value = DataTypeStringConverter.FormatDouble(((DoubleObservation)(o)).Value); } else if (o is IntegerObservation) { value = DataTypeStringConverter.FormatInteger(((IntegerObservation)(o)).Value); } else if (o is PositionObservation) { value = DataTypeStringConverter.FormatPosition(((PositionObservation)(o)).Value); } else if (o is StringObservation) { value = ((StringObservation)(o)).Value; } else if (o is StatisticsObservation) { value = DataTypeStringConverter.FormatStatistics(((StatisticsObservation)(o)).Value); } else { throw new NotSupportedException("Unsupported observation data type: " + o.GetType().ToString()); } string line = string.Format("{0},{1},{2}\r\n", io.ObservationId, o.Timestamp.ToString("o"), value); sb.Append(line); } } return(sb.ToString()); }
public static string ObservationToValueString(Observation o, DataType dataType) { switch (dataType) { case DataType.Boolean: return(DataTypeStringConverter.FormatBoolean(((BooleanObservation)o).Value)); case DataType.Double: return(DataTypeStringConverter.FormatDouble(((DoubleObservation)o).Value)); case DataType.Integer: return(DataTypeStringConverter.FormatInteger(((IntegerObservation)o).Value)); case DataType.Position: return(DataTypeStringConverter.FormatPosition(((PositionObservation)o).Value)); case DataType.String: return(((StringObservation)o).Value); case DataType.Statistics: return(DataTypeStringConverter.FormatStatistics(((StatisticsObservation)o).Value)); default: return(null); } }
public static Observation StringToObservation(DateTime timestamp, string value, DataType dataType) { switch (dataType) { case DataType.Boolean: return(new BooleanObservation() { Timestamp = timestamp, Value = DataTypeStringConverter.ParseBooleanValue(value) }); case DataType.Double: return(new DoubleObservation() { Timestamp = timestamp, Value = DataTypeStringConverter.ParseDoubleValue(value) }); case DataType.Integer: return(new IntegerObservation() { Timestamp = timestamp, Value = DataTypeStringConverter.ParseIntegerValue(value) }); case DataType.Position: return(new PositionObservation() { Timestamp = timestamp, Value = DataTypeStringConverter.ParsePositionValue(value) }); case DataType.String: return(new StringObservation() { Timestamp = timestamp, Value = value }); case DataType.Statistics: return(new StatisticsObservation() { Timestamp = timestamp, Value = DataTypeStringConverter.ParseStatisticsValue(value) }); default: return(null); } }
public void SetPosition(Position value) { Value = DataTypeStringConverter.FormatPosition(value); }
public void SetInteger(int value) { Value = DataTypeStringConverter.FormatInteger(value); }
public void SetDouble(double value) { Value = DataTypeStringConverter.FormatDouble(value); }
public void SetBoolean(bool value) { Value = DataTypeStringConverter.FormatBoolean(value); }
public Position ToPosition() { return(DataTypeStringConverter.ParsePositionValue(Value)); }
public int ToInteger() { return(DataTypeStringConverter.ParseIntegerValue(Value)); }
public double ToDouble() { return(DataTypeStringConverter.ParseDoubleValue(Value)); }
public bool ToBoolean() { return(DataTypeStringConverter.ParseBooleanValue(Value)); }
public CompactObservationPackage(string observations, Dictionary <int, DataType> observationDatatype) { Package = new ObservationPackage(); // Example: 1,2015-05-04T15:08:45Z,3.14 string pattern = "(?<observationId>\\d+),(?<timestamp>.*?),(?<value>.*)"; string[] lines = observations.Split(new string[] { "\r\n", "\n" }, StringSplitOptions.None); foreach (string line in lines) { if (line != null && line.Length > 0) { Regex regex = new Regex(pattern); Match match = regex.Match(line); int id; if (Int32.TryParse(match.Groups["observationId"].Value, out id)) { if (observationDatatype.ContainsKey(id)) { DateTime timestamp = DateTime.UtcNow; string ts = match.Groups["timestamp"].Value; UInt32 secondsSince1970 = 0; if (ts != "0") { if (DateTime.TryParse(ts, CultureInfo.InvariantCulture, DateTimeStyles.AdjustToUniversal | DateTimeStyles.AssumeUniversal, out timestamp)) { } else if (UInt32.TryParse(ts, out secondsSince1970)) { timestamp = new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc).AddSeconds(secondsSince1970); } else { throw new ArgumentException("Invalid timestamp in line\n" + line); } } string value = match.Groups["value"].Value; if (value != null) { switch (observationDatatype[id]) { case DataType.Boolean: bool booleanValue = DataTypeStringConverter.ParseBooleanValue(value); AppendObservation(id, new BooleanObservation() { Timestamp = timestamp, Value = booleanValue }); break; case DataType.Double: double doubleValue = DataTypeStringConverter.ParseDoubleValue(value); AppendObservation(id, new DoubleObservation() { Timestamp = timestamp, Value = doubleValue }); break; case DataType.Integer: int integerValue = DataTypeStringConverter.ParseIntegerValue(value); AppendObservation(id, new IntegerObservation() { Timestamp = timestamp, Value = integerValue }); break; case DataType.Position: Position positionValue = DataTypeStringConverter.ParsePositionValue(value); AppendObservation(id, new PositionObservation() { Timestamp = timestamp, Value = positionValue }); break; case DataType.String: if (value.Length < 4096) { AppendObservation(id, new StringObservation() { Timestamp = timestamp, Value = value }); break; } else { throw new ArgumentException("String values longer than 4096 characters are not supported. Tip: Use binary observation instead."); } case DataType.Statistics: DescriptiveStatistics statisticsValue = DataTypeStringConverter.ParseStatisticsValue(value); AppendObservation(id, new StatisticsObservation() { Timestamp = timestamp, Value = statisticsValue }); break; default: throw new ArgumentException("Unsupported datatype in line\n" + line); } } else { throw new ArgumentNullException("Value is null in line\n" + line); } } else { throw new ArgumentException("Unknown observation identifier in line\n" + line); } } else { throw new ArgumentException("Invalid ObservationId in line\n" + line); } } } }
private ObservationPackage GetBufferedObservations(out int maxId) { maxId = -1; ObservationPackageBuilder builder = new ObservationPackageBuilder(); using (LiteDatabase db = new LiteDatabase(_liteDBPathName)) { var col = db.GetCollection <BufferedObservation>(_OBSBUF_NAME); var records = col.Find(c => c.Uploaded == false).OrderBy(c => c.Id); IEnumerable <BufferedObservation> observations = null; if (UploadRowLimit > 0) { observations = records.Take(UploadRowLimit); } else { observations = records; } foreach (BufferedObservation bo in observations) { maxId = bo.Id; if (bo.Value != null) { Observation observation = null; switch ((DataType)(bo.DataType)) { case DataType.Boolean: observation = new BooleanObservation() { Timestamp = bo.Timestamp, Value = DataTypeStringConverter.ParseBooleanValue(bo.Value) }; break; case DataType.Double: observation = new DoubleObservation() { Timestamp = bo.Timestamp, Value = DataTypeStringConverter.ParseDoubleValue(bo.Value) }; break; case DataType.Integer: observation = new IntegerObservation() { Timestamp = bo.Timestamp, Value = DataTypeStringConverter.ParseIntegerValue(bo.Value) }; break; case DataType.Position: observation = new PositionObservation() { Timestamp = bo.Timestamp, Value = DataTypeStringConverter.ParsePositionValue(bo.Value) }; break; case DataType.String: observation = new StringObservation() { Timestamp = bo.Timestamp, Value = bo.Value }; break; case DataType.Statistics: observation = new StatisticsObservation() { Timestamp = bo.Timestamp, Value = DataTypeStringConverter.ParseStatisticsValue(bo.Value) }; break; default: throw new NotSupportedException("Unknown data type: " + bo.DataType.ToString()); } IdentifiedObservation io = new IdentifiedObservation() { ObservationId = bo.ObservationId, Observation = observation }; builder.Append(io); } } } return(builder.GetAsObservationPackage()); }
public DescriptiveStatistics ToStatistics() { return(DataTypeStringConverter.ParseStatisticsValue(Value)); }