private static void MakeFile(string source, string dest, CtpCompressionMode mode, EncodingMethod encoding)
{
using (var fs = new FileStream(source, FileMode.Open))
using (var fs2 = new FileStream(dest, FileMode.Create))
using (var ctp = new SttpFileReader(fs, false))
using (var ctp2 = new SttpFileWriter(fs2, false, mode, encoding))
{
while (true)
{
switch (ctp.Next())
{
case FileReaderItem.ProducerMetadata:
var md = ctp.GetMetadata();
ctp2.ProducerMetadata(md);
break;
case FileReaderItem.DataPoint:
var dp = new SttpDataPoint();
while (ctp.ReadDataPoint(dp))
{
ctp2.AddDataPoint(dp);
}
break;
case FileReaderItem.EndOfStream:
return;
default:
throw new ArgumentOutOfRangeException();
}
}
}
}
private void BenchmarkFile(string source, string dest, CtpCompressionMode mode, EncodingMethod encoding)
{
string newFileName = Path.ChangeExtension(source, ".txt");
//using (var raw = new StreamWriter(newFileName, false))
using (var fs = new FileStream(source, FileMode.Open))
using (var fs2 = new FileStream(dest, FileMode.Create))
using (var ctp = new SttpFileReader(fs, false))
using (var ctp2 = new SttpFileWriter(fs2, false, mode, encoding))
{
while (true)
{
switch (ctp.Next())
{
case FileReaderItem.ProducerMetadata:
var md = ctp.GetMetadata();
ctp2.ProducerMetadata(md);
break;
case FileReaderItem.DataPoint:
var dp = new SttpDataPoint();
while (ctp.ReadDataPoint(dp))
{
//if (dp.Value.AsSingle > 3000000)
//{
// dp.Value = dp.Value;
//}
//if (dp.Metadata.DataPointID.AsString.EndsWith(":DFreq0"))
//{
// dp.Value = new CtpNumeric((long)(dp.Value.AsSingle * 100), 2);
//}
//Names.Add(dp.Metadata.DataPointID.AsString);
//raw.WriteLine(dp.ToString());
PointCount++;
//dp.Value = (double)dp.Value;
//dp.Value = (long)dp.Value*1000;
ctp2.AddDataPoint(dp);
}
break;
case FileReaderItem.EndOfStream:
return;
default:
throw new ArgumentOutOfRangeException();
}
}
}
}
private void ReadSttp(string fileName)
{
DataTable dt = new DataTable();
dt.Columns.Add("Command", typeof(string));
dt.Columns.Add("Count", typeof(int));
dt.Columns.Add("Record", typeof(string));
using (var fs = new FileStream(fileName, FileMode.Open))
using (var ctp = new SttpFileReader(fs, false))
{
while (true)
{
switch (ctp.Next())
{
case FileReaderItem.ProducerMetadata:
var md = ctp.GetMetadata();
dt.Rows.Add("Metadata", md.ToCommand().ToXML().Length, md.ToString());
break;
case FileReaderItem.DataPoint:
var sb = new StringBuilder();
var dp = new SttpDataPoint();
int cnt = 0;
while (ctp.ReadDataPoint(dp))
{
cnt++;
sb.Append(dp.Value.AsString);
sb.Append(" ");
}
dt.Rows.Add("Points", cnt, sb.ToString());
break;
case FileReaderItem.EndOfStream:
dataGridView1.DataSource = dt;
return;
default:
throw new ArgumentOutOfRangeException();
}
}
}
}
private int GetChannelID(SttpDataPoint point, out bool includeMetadata)
{
includeMetadata = false;
if (!m_pointIDToChannelIDMapping.TryGetValue(point.DataPoint, out var channelID))
{
includeMetadata = true;
channelID = m_metadataCount;
m_pointIDToChannelIDMapping.Add(point.DataPoint, channelID);
if (m_metadataCount + 1 == m_metadata.Length)
{
var newList = new SttpDataPointID[m_metadata.Length * 2];
m_metadata.CopyTo(newList, 0);
m_metadata = newList;
}
m_metadata[m_metadataCount] = point.DataPoint;
m_metadataCount++;
}
return(channelID);
}
//internal void QueueDataPoint(DataPoint dataPoint)
//{
// lock (m_dataPointQueue)
// m_dataPointQueue.Add(dataPoint);
//}
private void CollateData()
{
// TODO: This is prototype example code - use thread signaling and/or handle in a better way...
while (m_enabled)
{
Thread.Sleep(100);
//DataPoint[] dataPoints;
//lock (m_dataPointQueue)
//{
// dataPoints = m_dataPointQueue.ToArray();
// m_dataPointQueue.Clear();
//}
SttpDataPoint wire = new SttpDataPoint();
//PatchSignalMapping(dataPoints);
//m_encoder.DataPoint.BeginCommand();
//foreach (var point in dataPoints)
//{
// wire.ID = m_signalMapping[point.Key.UniqueID].RuntimeID;
// Array.Copy(point.Value, 0, wire.Value, 0, point.ValueLength);
// wire.BulkDataValueID = 0;
// wire.ValueLength = (uint)point.ValueLength;
// wire.Time = new SttpTimestamp(point.Time);
// wire.TimeQualityFlags = point.Flags;
// wire.DataQualityFlags = point.QualityFlags;
// //m_encoder.DataPoint.SendDataPoint(wire);
//}
//m_encoder.DataPoint.EndCommand();
}
}
public abstract bool Read(SttpDataPoint dataPoint);
public override bool Read(SttpDataPoint dataPoint)
{
TryAgain:
if (m_stream.IsEmpty)
{
return(false);
}
m_lastChannelID++;
CtpObject value = m_stream.Read();
if (value.ValueTypeCode == CtpTypeCode.Integer)
{
long code = value.IsInteger;
if (0 <= code && code <= 15)
{
bool channelIDChanged = (code & 1) != 0;
bool hasMetadata = (code & 2) != 0;
bool qualityChanged = (code & 4) != 0;
bool timeChanged = (code & 8) != 0;
if (channelIDChanged)
{
m_lastChannelID = m_stream.Read().AsInt32;
}
if (hasMetadata)
{
Assign(new SttpDataPointID(m_stream.Read()), m_lastChannelID);
}
if (qualityChanged)
{
m_lastQuality = m_stream.Read().AsInt64;
}
if (timeChanged)
{
m_lastTimestamp = m_stream.Read().AsCtpTime;
}
value = m_stream.Read();
}
else
{
value = code - 16;
}
}
dataPoint.DataPoint = GetMetadata(m_lastChannelID);
dataPoint.Quality = m_lastQuality;
dataPoint.Time = m_lastTimestamp;
dataPoint.Value = value;
if (dataPoint.DataPoint == null)
{
goto TryAgain;
}
return(true);
}
public override int AddDataPoint(SttpDataPoint point)
{
byte code = 0;
//CtpObject value = point.Value;
int channelID = m_lastChannelID += 1; //Note the += 1
//Most of the time, measurements will be sequential, this limits a dictionary lookup
if (channelID >= m_metadataCount || !ReferenceEquals(m_metadata[channelID], point.DataPoint))
{
//A reference equals should be good enough to try
channelID = GetChannelID(point, out var includeMetadata);
if (m_lastChannelID != channelID)
{
code |= 1;
m_lastChannelID = channelID;
}
if (includeMetadata)
{
code |= 2;
}
}
if (point.Quality != m_lastQuality)
{
code |= 4;
m_lastQuality = point.Quality;
}
if (point.Time.Ticks != m_lastTimestamp)
{
code |= 8;
m_lastTimestamp = point.Time.Ticks;
}
if (code > 0 || (point.Value.ValueTypeCode == CtpTypeCode.Integer && point.Value.UnsafeInteger > long.MaxValue - 16))
{
m_stream.WriteExact(code);
if ((code & 1) != 0)
{
m_stream.WriteExact(channelID);
}
if ((code & 2) != 0)
{
m_stream.Write(point.DataPoint.ID);
}
if ((code & 4) != 0)
{
m_stream.WriteExact(point.Quality);
}
if ((code & 8) != 0)
{
m_stream.Write(point.Time);
}
}
else if (point.Value.ValueTypeCode == CtpTypeCode.Integer)
{
//10% of the time, it's an integer
if (point.Value.UnsafeInteger >= 0)
{
m_stream.WriteExact(point.Value.UnsafeInteger + 16);
}
else
{
m_stream.WriteExact(point.Value.UnsafeInteger);
}
return(m_stream.Length);
}
if (point.Value.ValueTypeCode == CtpTypeCode.Single)
{
m_stream.WriteExact(point.Value.UnsafeSingle); //90% of the time, its single.
}
else
{
m_stream.Write(point.Value);
}
return(m_stream.Length);
}
public abstract int AddDataPoint(SttpDataPoint point);
