private void ProcessBinaryMeasurements(IEnumerable <IBinaryMeasurement> measurements, long frameLevelTimestamp, bool useCompactMeasurementFormat, bool usePayloadCompression)
{
// Create working buffer
using (BlockAllocatedMemoryStream workingBuffer = new BlockAllocatedMemoryStream())
{
// Serialize data packet flags into response
DataPacketFlags flags = DataPacketFlags.Synchronized;
if (useCompactMeasurementFormat)
{
flags |= DataPacketFlags.Compact;
}
workingBuffer.WriteByte((byte)flags);
// Serialize frame timestamp into data packet - this only occurs in synchronized data packets,
// unsynchronized subscriptions always include timestamps in the serialized measurements
workingBuffer.Write(BigEndian.GetBytes(frameLevelTimestamp), 0, 8);
// Serialize total number of measurement values to follow
workingBuffer.Write(BigEndian.GetBytes(measurements.Count()), 0, 4);
if (usePayloadCompression && m_compressionModes.HasFlag(CompressionModes.TSSC))
{
throw new InvalidOperationException("TSSC must be processed at the frame level. Please check call stack - this is considered an error.");
}
// Attempt compression when requested - encoding of compressed buffer only happens if size would be smaller than normal serialization
if (!usePayloadCompression || !measurements.Cast <CompactMeasurement>().CompressPayload(workingBuffer, m_compressionStrength, false, ref flags))
{
// Serialize measurements to data buffer
foreach (IBinaryMeasurement measurement in measurements)
{
measurement.CopyBinaryImageToStream(workingBuffer);
}
}
// Update data packet flags if it has updated compression flags
if ((flags & DataPacketFlags.Compressed) > 0)
{
workingBuffer.Seek(0, SeekOrigin.Begin);
workingBuffer.WriteByte((byte)flags);
}
// Publish data packet to client
if ((object)m_parent != null)
{
m_parent.SendClientResponse(m_clientID, ServerResponse.DataPacket, ServerCommand.Subscribe, workingBuffer.ToArray());
}
}
}
private void ProcessBinaryMeasurements(IEnumerable <IBinaryMeasurement> measurements, bool useCompactMeasurementFormat, bool usePayloadCompression)
{
// Create working buffer
using (BlockAllocatedMemoryStream workingBuffer = new BlockAllocatedMemoryStream())
{
// Serialize data packet flags into response
DataPacketFlags flags = DataPacketFlags.NoFlags; // No flags means bit is cleared, i.e., unsynchronized
if (useCompactMeasurementFormat)
{
flags |= DataPacketFlags.Compact;
}
workingBuffer.WriteByte((byte)flags);
// No frame level timestamp is serialized into the data packet since all data is unsynchronized and essentially
// published upon receipt, however timestamps are optionally included in the serialized measurements.
// Serialize total number of measurement values to follow
workingBuffer.Write(BigEndian.GetBytes(measurements.Count()), 0, 4);
// Attempt compression when requested - encoding of compressed buffer only happens if size would be smaller than normal serialization
if (!usePayloadCompression || !measurements.Cast <CompactMeasurement>().CompressPayload(workingBuffer, m_compressionStrength, m_includeTime, ref flags))
{
// Serialize measurements to data buffer
foreach (IBinaryMeasurement measurement in measurements)
{
measurement.CopyBinaryImageToStream(workingBuffer);
}
}
// Update data packet flags if it has updated compression flags
if ((flags & DataPacketFlags.Compressed) > 0)
{
workingBuffer.Seek(0, SeekOrigin.Begin);
workingBuffer.WriteByte((byte)flags);
}
// Publish data packet to client
if ((object)m_parent != null)
{
m_parent.SendClientResponse(m_clientID, ServerResponse.DataPacket, ServerCommand.Subscribe, workingBuffer.ToArray());
}
// Track last publication time
m_lastPublishTime = DateTime.UtcNow.Ticks;
}
}
private void ProcessBinaryMeasurements(IEnumerable <IBinaryMeasurement> measurements, long frameLevelTimestamp, bool useCompactMeasurementFormat, bool usePayloadCompression)
{
// Reset working buffer
m_workingBuffer.SetLength(0);
// Serialize data packet flags into response
DataPacketFlags flags = DataPacketFlags.Synchronized;
if (useCompactMeasurementFormat)
{
flags |= DataPacketFlags.Compact;
}
m_workingBuffer.WriteByte((byte)flags);
// Serialize frame timestamp into data packet - this only occurs in synchronized data packets,
// unsynchronized subscriptions always include timestamps in the serialized measurements
m_workingBuffer.Write(BigEndian.GetBytes(frameLevelTimestamp), 0, 8);
// Serialize total number of measurement values to follow
m_workingBuffer.Write(BigEndian.GetBytes(measurements.Count()), 0, 4);
// Attempt compression when requested - encoding of compressed buffer only happens if size would be smaller than normal serialization
if (!usePayloadCompression || !measurements.Cast <CompactMeasurement>().CompressPayload(m_workingBuffer, m_compressionStrength, false, ref flags))
{
// Serialize measurements to data buffer
foreach (IBinaryMeasurement measurement in measurements)
{
measurement.CopyBinaryImageToStream(m_workingBuffer);
}
}
// Update data packet flags if it has updated compression flags
if ((flags & DataPacketFlags.Compressed) > 0)
{
m_workingBuffer.Seek(0, SeekOrigin.Begin);
m_workingBuffer.WriteByte((byte)flags);
}
// Publish data packet to client
if ((object)m_parent != null)
{
m_parent.SendClientResponse(m_workingBuffer, m_clientID, ServerResponse.DataPacket, ServerCommand.Subscribe, m_workingBuffer.ToArray());
}
}
/// <summary>
/// Reads XML from the configuration file.
/// </summary>
/// <param name="reader">The <see cref="System.Xml.XmlReader"/> object, which reads from the configuration file.</param>
protected override void DeserializeSection(XmlReader reader)
{
using (BlockAllocatedMemoryStream configSectionStream = new BlockAllocatedMemoryStream())
{
XmlDocument configSection = new XmlDocument();
configSection.Load(reader);
configSection.Save(configSectionStream);
// Adds all the categories that are under the categorizedSettings section of the configuration file
// to the property collection. Again, this is essentially doing what marking a property with the
// <ConfigurationProperty()> attribute does. If this is not done, then an exception will be raised
// when the category elements are being deserialized.
if ((object)configSection.DocumentElement != null)
{
XmlNodeList categories = configSection.DocumentElement.SelectNodes("*");
if ((object)categories != null)
{
foreach (XmlNode category in categories)
{
ConfigurationProperty configProperty = new ConfigurationProperty(category.Name, typeof(CategorizedSettingsElementCollection));
base.Properties.Add(configProperty);
if ((object)m_sections != null)
{
CategorizedSettingsElementCollection settingsCategory = new CategorizedSettingsElementCollection
{
Name = category.Name,
Section = this,
};
settingsCategory.SetCryptoKey(m_cryptoKey);
m_sections.Add(category.Name, settingsCategory);
// Read all elements within this category section
XmlNodeList elements = category.SelectNodes("*");
SettingScope scope;
if ((object)elements != null)
{
foreach (XmlNode element in elements)
{
CategorizedSettingsElement categorySetting = new CategorizedSettingsElement(settingsCategory);
categorySetting.Name = element.GetAttributeValue("name");
categorySetting.Value = element.GetAttributeValue("value");
categorySetting.Description = element.GetAttributeValue("description") ?? "";
categorySetting.Encrypted = element.GetAttributeValue("encrypted").ToNonNullNorWhiteSpace("false").ParseBoolean();
if (Enum.TryParse(element.GetAttributeValue("scope").ToNonNullNorWhiteSpace("Application"), out scope))
{
categorySetting.Scope = scope;
}
else
{
categorySetting.Scope = SettingScope.Application;
}
settingsCategory.Add(categorySetting);
}
}
}
}
}
}
m_sectionLoaded = true;
if ((object)m_sections == null)
{
configSectionStream.Seek(0, SeekOrigin.Begin);
base.DeserializeSection(XmlReader.Create(configSectionStream));
}
}
}
