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));
}
