/// <summary>
/// Creates a new local system cache from one that was received remotely.
/// </summary>
/// <param name="dataSource"><see cref="DataSet"/> based data source used to interpret local measurement keys.</param>
/// <param name="remoteCache">Deserialized remote signal index cache.</param>
public SignalIndexCache(DataSet dataSource, SignalIndexCache remoteCache)
{
m_subscriberID = remoteCache.SubscriberID;
// If active measurements are defined, interpret signal cache in context of current measurement key definitions
if (dataSource != null && dataSource.Tables.Contains("ActiveMeasurements"))
{
DataTable activeMeasurements = dataSource.Tables["ActiveMeasurements"];
m_reference = new ConcurrentDictionary <int, MeasurementKey>();
foreach (KeyValuePair <int, MeasurementKey> signalIndex in remoteCache.Reference)
{
Guid signalID = signalIndex.Value.SignalID;
DataRow[] filteredRows = activeMeasurements.Select("SignalID = '" + signalID.ToString() + "'");
if (filteredRows.Length > 0)
{
DataRow row = filteredRows[0];
MeasurementKey key = MeasurementKey.LookUpOrCreate(signalID, row["ID"].ToNonNullString(MeasurementKey.Undefined.ToString()));
m_reference.TryAdd(signalIndex.Key, key);
}
}
m_unauthorizedSignalIDs = remoteCache.UnauthorizedSignalIDs;
}
else
{
// Just use remote signal index cache as-is if no local configuration exists
m_reference = remoteCache.Reference;
m_unauthorizedSignalIDs = remoteCache.UnauthorizedSignalIDs;
}
}
/// <summary>
/// Creates a new <see cref="SubscriberAdapter"/>.
/// </summary>
/// <param name="parent">Reference to parent.</param>
/// <param name="clientID"><see cref="Guid"/> based client connection ID.</param>
/// <param name="subscriberID"><see cref="Guid"/> based subscriber ID.</param>
/// <param name="compressionModes"><see cref="CompressionModes"/> requested by client.</param>
public SubscriberAdapter(DataPublisher parent, Guid clientID, Guid subscriberID, CompressionModes compressionModes)
{
m_parent = parent;
m_clientID = clientID;
m_subscriberID = subscriberID;
m_compressionModes = compressionModes;
m_signalIndexCache = new SignalIndexCache();
m_signalIndexCache.SubscriberID = subscriberID;
m_bufferBlockCache = new List <byte[]>();
m_bufferBlockCacheLock = new object();
m_tsscSyncLock = new object();
}
/// <summary>
/// Creates a new <see cref="CompactMeasurement"/>.
/// </summary>
/// <param name="signalIndexCache">Signal index cache used to serialize or deserialize runtime information.</param>
/// <param name="includeTime">Set to <c>true</c> to include time in serialized packet; otherwise <c>false</c>.</param>
/// <param name="baseTimeOffsets">Base time offset array - set to <c>null</c> to use full fidelity measurement time.</param>
/// <param name="timeIndex">Time index to use for base offset.</param>
/// <param name="useMillisecondResolution">Flag that determines if millisecond resolution is in use for this serialization.</param>
public CompactMeasurement(SignalIndexCache signalIndexCache, bool includeTime = true, long[] baseTimeOffsets = null, int timeIndex = 0, bool useMillisecondResolution = false)
{
m_signalIndexCache = signalIndexCache;
m_includeTime = includeTime;
// We keep a clone of the base time offsets, if provided, since array contents can change at any time
if ((object)baseTimeOffsets == null)
{
m_baseTimeOffsets = s_emptyBaseTimeOffsets;
}
else
{
m_baseTimeOffsets = new[] { baseTimeOffsets[0], baseTimeOffsets[1] }
};
m_timeIndex = timeIndex;
m_useMillisecondResolution = useMillisecondResolution;
}