public override void Finish(long sumTotalTermFreq, long sumDocFreq, int docCount)
{
if (_numTerms <= 0) return;
var metadata = new FieldMetaData
{
FieldInfo = _fieldInfo,
NumTerms = _numTerms,
SumTotalTermFreq = sumTotalTermFreq,
SumDocFreq = sumDocFreq,
DocCount = docCount,
LongsSize = _longsSize,
SkipOut = _skipOut,
StatsOut = _statsOut,
MetaLongsOut = _metaLongsOut,
MetaBytesOut = _metaBytesOut,
Dict = _builder.Finish()
};
_outerInstance._fields.Add(metadata);
}
private static void CompareFieldMetaData(FieldMetaData source, FieldMetaData mirror)
{
Assert.AreEqual <string>(source.ProcessValueName, mirror.ProcessValueName);
Assert.AreEqual <string>(source.SymbolicName, mirror.SymbolicName);
Compare(source.TypeInformation, mirror.TypeInformation);
}
/// <summary>
/// Decode the Content of the Payload and create a DataSet object from it
/// </summary>
private DataSet DecodePayloadContent(JsonDecoder jsonDecoder, DataSetReaderDataType dataSetReader)
{
TargetVariablesDataType targetVariablesData =
ExtensionObject.ToEncodeable(dataSetReader.SubscribedDataSet)
as TargetVariablesDataType;
DataSetMetaDataType dataSetMetaData = dataSetReader.DataSetMetaData;
object token;
List <DataValue> dataValues = new List <DataValue>();
for (int index = 0; index < dataSetMetaData?.Fields.Count; index++)
{
FieldMetaData fieldMetaData = dataSetMetaData?.Fields[index];
if (jsonDecoder.ReadField(fieldMetaData.Name, out token))
{
switch (m_fieldTypeEncoding)
{
case FieldTypeEncodingMask.Variant:
Variant variantValue = jsonDecoder.ReadVariant(fieldMetaData.Name);
dataValues.Add(new DataValue(variantValue));
break;
case FieldTypeEncodingMask.RawData:
object value = DecodeRawData(jsonDecoder, dataSetMetaData?.Fields[index], dataSetMetaData?.Fields[index].Name);
dataValues.Add(new DataValue(new Variant(value)));
break;
case FieldTypeEncodingMask.DataValue:
bool wasPush2 = jsonDecoder.PushStructure(fieldMetaData.Name);
DataValue dataValue = new DataValue(Variant.Null);
try
{
if (wasPush2 && jsonDecoder.ReadField("Value", out token))
{
// the Value was encoded using the non reversible json encoding
token = DecodeRawData(jsonDecoder, dataSetMetaData?.Fields[index], "Value");
dataValue = new DataValue(new Variant(token));
}
else
{
// handle Good StatusCode that was not encoded
if (dataSetMetaData?.Fields[index].BuiltInType == (byte)BuiltInType.StatusCode)
{
dataValue = new DataValue(new Variant(new StatusCode(StatusCodes.Good)));
}
}
if ((FieldContentMask & DataSetFieldContentMask.StatusCode) != 0)
{
if (jsonDecoder.ReadField("StatusCode", out token))
{
bool wasPush3 = jsonDecoder.PushStructure("StatusCode");
if (wasPush3)
{
dataValue.StatusCode = jsonDecoder.ReadStatusCode("Code");
jsonDecoder.Pop();
}
}
}
if ((FieldContentMask & DataSetFieldContentMask.SourceTimestamp) != 0)
{
dataValue.SourceTimestamp = jsonDecoder.ReadDateTime("SourceTimestamp");
}
if ((FieldContentMask & DataSetFieldContentMask.SourcePicoSeconds) != 0)
{
dataValue.SourcePicoseconds = jsonDecoder.ReadUInt16("SourcePicoseconds");
}
if ((FieldContentMask & DataSetFieldContentMask.ServerTimestamp) != 0)
{
dataValue.ServerTimestamp = jsonDecoder.ReadDateTime("ServerTimestamp");
}
if ((FieldContentMask & DataSetFieldContentMask.ServerPicoSeconds) != 0)
{
dataValue.ServerPicoseconds = jsonDecoder.ReadUInt16("ServerPicoseconds");
}
dataValues.Add(dataValue);
}
finally
{
if (wasPush2)
{
jsonDecoder.Pop();
}
}
break;
}
}
else
{
switch (m_fieldTypeEncoding)
{
case FieldTypeEncodingMask.Variant:
case FieldTypeEncodingMask.RawData:
// handle StatusCodes.Good which is not encoded and therefore must be created at decode
if (dataSetMetaData?.Fields[index].BuiltInType == (byte)BuiltInType.StatusCode)
{
dataValues.Add(new DataValue(new Variant(new StatusCode(StatusCodes.Good))));
}
else
{
// the field is null
dataValues.Add(new DataValue(Variant.Null));
}
break;
}
}
}
if (dataValues.Count != dataSetMetaData?.Fields.Count)
{
return(null);
}
//build the DataSet Fields collection based on the decoded values and the target
List <Field> dataFields = new List <Field>();
for (int i = 0; i < dataValues.Count; i++)
{
Field dataField = new Field();
dataField.FieldMetaData = dataSetMetaData?.Fields[i];
dataField.Value = dataValues[i];
if (targetVariablesData != null && targetVariablesData.TargetVariables != null &&
i < targetVariablesData.TargetVariables.Count)
{
// remember the target Attribute and target nodeId
dataField.TargetAttribute = targetVariablesData.TargetVariables[i].AttributeId;
dataField.TargetNodeId = targetVariablesData.TargetVariables[i].TargetNodeId;
}
dataFields.Add(dataField);
}
// build the dataset object
DataSet dataSet = new DataSet(dataSetMetaData?.Name);
dataSet.Fields = dataFields.ToArray();
dataSet.DataSetWriterId = DataSetWriterId;
dataSet.SequenceNumber = SequenceNumber;
return(dataSet);
}
/// <summary>
/// Decode field message data from decoder and using a DataSetReader
/// </summary>
/// <param name="binaryDecoder"></param>
/// <param name="dataSetReader"></param>
/// <returns></returns>
private DataSet DecodeFieldMessageData(BinaryDecoder binaryDecoder, DataSetReaderDataType dataSetReader)
{
DataSetMetaDataType dataSetMetaData = dataSetReader.DataSetMetaData;
try
{
ushort fieldCount = 0;
FieldTypeEncodingMask fieldType = (FieldTypeEncodingMask)(((byte)DataSetFlags1 & kFieldTypeUsedBits) >> 1);
if (fieldType == FieldTypeEncodingMask.RawData)
{
if (dataSetMetaData != null)
{
// metadata should provide field count
fieldCount = (ushort)dataSetMetaData.Fields.Count;
}
}
else
{
fieldCount = binaryDecoder.ReadUInt16("DataSetFieldCount");
}
TargetVariablesDataType targetVariablesData =
ExtensionObject.ToEncodeable(dataSetReader.SubscribedDataSet) as TargetVariablesDataType;
// check configuration version
List <DataValue> dataValues = new List <DataValue>();
switch (fieldType)
{
case FieldTypeEncodingMask.Variant:
for (int i = 0; i < fieldCount; i++)
{
dataValues.Add(new DataValue(binaryDecoder.ReadVariant("Variant")));
}
break;
case FieldTypeEncodingMask.DataValue:
for (int i = 0; i < fieldCount; i++)
{
dataValues.Add(binaryDecoder.ReadDataValue("DataValue"));
}
break;
case FieldTypeEncodingMask.RawData:
if (dataSetMetaData != null)
{
for (int i = 0; i < fieldCount; i++)
{
FieldMetaData fieldMetaData = dataSetMetaData.Fields[i];
if (fieldMetaData != null)
{
var decodedValue = DecodeRawData(binaryDecoder, fieldMetaData);
dataValues.Add(new DataValue(new Variant(decodedValue)));
}
}
}
// else the decoding is compromised for RawData type
break;
case FieldTypeEncodingMask.Reserved:
// ignore
break;
}
List <Field> dataFields = new List <Field>();
for (int i = 0; i < dataValues.Count; i++)
{
Field dataField = new Field();
dataField.FieldMetaData = dataSetMetaData?.Fields[i];
dataField.Value = dataValues[i];
if (targetVariablesData != null && targetVariablesData.TargetVariables != null &&
i < targetVariablesData.TargetVariables.Count)
{
// remember the target Attribute and target nodeId
dataField.TargetAttribute = targetVariablesData.TargetVariables[i].AttributeId;
dataField.TargetNodeId = targetVariablesData.TargetVariables[i].TargetNodeId;
}
dataFields.Add(dataField);
}
DataSet dataSet = new DataSet(dataSetMetaData?.Name);
dataSet.Fields = dataFields.ToArray();
dataSet.DataSetWriterId = DataSetWriterId;
dataSet.SequenceNumber = SequenceNumber;
return(dataSet);
}
catch (Exception ex)
{
Utils.Trace(ex, "UadpDataSetMessage.DecodeFieldMessageData");
return(null);
}
}
private static void WriteFieldValue <TType>(BitWriter r, FieldMetaData fieldMeta, object value) where TType : struct
{
r.Write((TType)value, 32 - fieldMeta.Bits);
}
private void AddFieldToSelected(FieldMetaData field)
{
_selectedFields.Add(field);
_availableFields.Remove(field);
}
private void RemoveFieldFromSelected(FieldMetaData field)
{
_availableFields.Add(field);
_selectedFields.Remove(field);
}
public FieldMetaDataTreeNode(FieldMetaData field) : base(field.Title)
{
_field = field;
}
public unsafe WDB6Reader(Stream stream)
{
using (var reader = new BinaryReader(stream, Encoding.UTF8))
{
if (reader.BaseStream.Length < HeaderSize)
{
throw new InvalidDataException("WDB6 file is corrupted!");
}
uint magic = reader.ReadUInt32();
if (magic != WDB6FmtSig)
{
throw new InvalidDataException("WDB6 file is corrupted!");
}
RecordsCount = reader.ReadInt32();
FieldsCount = reader.ReadInt32();
RecordSize = reader.ReadInt32();
StringTableSize = reader.ReadInt32();
TableHash = reader.ReadUInt32();
LayoutHash = reader.ReadUInt32();
MinIndex = reader.ReadInt32();
MaxIndex = reader.ReadInt32();
int locale = reader.ReadInt32();
int copyTableSize = reader.ReadInt32();
Flags = (DB2Flags)reader.ReadUInt16();
IdFieldIndex = reader.ReadUInt16();
int totalFieldCount = reader.ReadInt32();
int commonDataSize = reader.ReadInt32();
if (RecordsCount == 0)
{
return;
}
// field meta data
m_meta = reader.ReadArray <FieldMetaData>(FieldsCount);
if (!Flags.HasFlagExt(DB2Flags.Sparse))
{
// records data
recordsData = reader.ReadBytes(RecordsCount * RecordSize);
Array.Resize(ref recordsData, recordsData.Length + 8); // pad with extra zeros so we don't crash when reading
// string table
m_stringsTable = new Dictionary <long, string>(StringTableSize / 0x20);
for (int i = 0; i < StringTableSize;)
{
long oldPos = reader.BaseStream.Position;
m_stringsTable[i] = reader.ReadCString();
i += (int)(reader.BaseStream.Position - oldPos);
}
}
else
{
// sparse data with inlined strings
recordsData = reader.ReadBytes(StringTableSize - (int)reader.BaseStream.Position);
int sparseCount = MaxIndex - MinIndex + 1;
m_sparseEntries = new List <SparseEntry>(sparseCount);
m_copyData = new Dictionary <int, int>(sparseCount);
var sparseIdLookup = new Dictionary <uint, int>(sparseCount);
for (int i = 0; i < sparseCount; i++)
{
SparseEntry sparse = reader.Read <SparseEntry>();
if (sparse.Offset == 0 || sparse.Size == 0)
{
continue;
}
if (sparseIdLookup.TryGetValue(sparse.Offset, out int copyId))
{
m_copyData[MinIndex + i] = copyId;
}
else
{
m_sparseEntries.Add(sparse);
sparseIdLookup.Add(sparse.Offset, MinIndex + i);
}
}
}
// secondary key
if (Flags.HasFlagExt(DB2Flags.SecondaryKey))
{
m_foreignKeyData = reader.ReadArray <int>(MaxIndex - MinIndex + 1);
}
// index table
if (Flags.HasFlagExt(DB2Flags.Index))
{
m_indexData = reader.ReadArray <int>(RecordsCount);
}
// duplicate rows data
if (m_copyData == null)
{
m_copyData = new Dictionary <int, int>(copyTableSize / 8);
}
for (int i = 0; i < copyTableSize / 8; i++)
{
m_copyData[reader.ReadInt32()] = reader.ReadInt32();
}
if (commonDataSize > 0)
{
Array.Resize(ref m_meta, totalFieldCount);
int fieldCount = reader.ReadInt32();
m_commonData = new Dictionary <int, Value32> [fieldCount];
// HACK as of 24473 values are 4 byte aligned
// try to calculate this by seeing if all <id, value> tuples are 8 bytes
bool aligned = (commonDataSize - 4 - (fieldCount * 5)) % 8 == 0;
for (int i = 0; i < fieldCount; i++)
{
int count = reader.ReadInt32();
byte type = reader.ReadByte();
int size = aligned ? 4 : (32 - CommonTypeBits[type]) >> 3;
// add the new meta entry
if (i > FieldsCount)
{
m_meta[i] = new FieldMetaData()
{
Bits = CommonTypeBits[type],
Offset = (short)(m_meta[i - 1].Offset + ((32 - m_meta[i - 1].Bits) >> 3))
};
}
var commonValues = new Dictionary <int, Value32>(count);
for (int j = 0; j < count; j++)
{
int id = reader.ReadInt32();
byte[] buffer = reader.ReadBytes(size);
Value32 value = Unsafe.ReadUnaligned <Value32>(ref buffer[0]);
commonValues.Add(id, value);
}
m_commonData[i] = commonValues;
}
}
int position = 0;
for (int i = 0; i < RecordsCount; i++)
{
BitReader bitReader = new BitReader(recordsData)
{
Position = 0
};
if (Flags.HasFlagExt(DB2Flags.Sparse))
{
bitReader.Position = position;
position += m_sparseEntries[i].Size * 8;
}
else
{
bitReader.Offset = i * RecordSize;
}
IDBRow rec = new WDB6Row(this, bitReader, Flags.HasFlagExt(DB2Flags.Index) ? m_indexData[i] : -1, i);
_Records.Add(i, rec);
}
}
}
/// <summary>
/// Increment value
/// maxAllowedValue - maximum incremented value before reset value to initial value
/// step - the increment value
/// </summary>
/// <param name="variable"></param>
/// <param name="namespaceIndex"></param>
/// <param name="maxAllowedValue"></param>
/// <param name="step"></param>
private void IncrementValue(FieldMetaData variable, ushort namespaceIndex, long maxAllowedValue = Int32.MaxValue, int step = 0)
{
// Read value to be incremented
DataValue dataValue = m_dataStore.ReadPublishedDataItem(new NodeId(variable.Name, namespaceIndex), Attributes.Value);
if (dataValue.Value == null)
{
return;
}
bool valueUpdated = false;
BuiltInType expectedType = TypeInfo.GetBuiltInType(variable.DataType);
switch (expectedType)
{
case BuiltInType.Boolean:
if (variable.ValueRank == ValueRanks.Scalar)
{
Boolean boolValue = Convert.ToBoolean(dataValue.Value);
dataValue.Value = !boolValue;
valueUpdated = true;
}
break;
case BuiltInType.Byte:
if (variable.ValueRank == ValueRanks.Scalar)
{
byte byteValue = Convert.ToByte(dataValue.Value);
dataValue.Value = (byte)(byteValue + 1);
valueUpdated = true;
}
break;
case BuiltInType.Int16:
if (variable.ValueRank == ValueRanks.Scalar)
{
Int16 int16Value = Convert.ToInt16(dataValue.Value);
int intIdentifier = int16Value;
Interlocked.CompareExchange(ref intIdentifier, 0, Int16.MaxValue);
dataValue.Value = (Int16)Interlocked.Increment(ref intIdentifier);
valueUpdated = true;
}
break;
case BuiltInType.Int32:
if (variable.ValueRank == ValueRanks.Scalar)
{
Int32 int32Value = Convert.ToInt32(dataValue.Value);
if (step > 0)
{
int32Value += (step - 1);
}
if (int32Value > maxAllowedValue)
{
int32Value = 0;
}
dataValue.Value = Interlocked.Increment(ref int32Value);
valueUpdated = true;
}
break;
case BuiltInType.SByte:
if (variable.ValueRank == ValueRanks.Scalar)
{
SByte sbyteValue = Convert.ToSByte(dataValue.Value);
int intIdentifier = sbyteValue;
Interlocked.CompareExchange(ref intIdentifier, 0, SByte.MaxValue);
dataValue.Value = (SByte)Interlocked.Increment(ref intIdentifier);
valueUpdated = true;
}
break;
case BuiltInType.UInt16:
if (variable.ValueRank == ValueRanks.Scalar)
{
UInt16 uint16Value = Convert.ToUInt16(dataValue.Value);
int intIdentifier = uint16Value;
Interlocked.CompareExchange(ref intIdentifier, 0, UInt16.MaxValue);
dataValue.Value = (UInt16)Interlocked.Increment(ref intIdentifier);
valueUpdated = true;
}
break;
case BuiltInType.UInt32:
if (variable.ValueRank == ValueRanks.Scalar)
{
UInt32 uint32Value = Convert.ToUInt32(dataValue.Value);
long longIdentifier = uint32Value;
Interlocked.CompareExchange(ref longIdentifier, 0, UInt32.MaxValue);
dataValue.Value = (UInt32)Interlocked.Increment(ref longIdentifier);
valueUpdated = true;
}
else if (variable.ValueRank == ValueRanks.OneDimension)
{
uint[] values = dataValue.Value as uint[];
if (values != null)
{
for (int i = 0; i < values.Length; i++)
{
UInt32 uint32Value = values[i];
long longIdentifier = uint32Value;
Interlocked.CompareExchange(ref longIdentifier, 0, UInt32.MaxValue);
values[i] = (UInt32)Interlocked.Increment(ref longIdentifier);
}
valueUpdated = true;
}
}
break;
case BuiltInType.UInt64:
if (variable.ValueRank == ValueRanks.Scalar)
{
UInt64 uint64Value = Convert.ToUInt64(dataValue.Value);
float longIdentifier = uint64Value + 1;
Interlocked.CompareExchange(ref longIdentifier, 0, UInt64.MaxValue);
dataValue.Value = (UInt64)longIdentifier;
valueUpdated = true;
}
break;
case BuiltInType.Float:
if (variable.ValueRank == ValueRanks.Scalar)
{
float floatValue = Convert.ToSingle(dataValue.Value);
Interlocked.CompareExchange(ref floatValue, 0, float.MaxValue);
dataValue.Value = floatValue + 1;
valueUpdated = true;
}
break;
case BuiltInType.Double:
if (variable.ValueRank == ValueRanks.Scalar)
{
double doubleValue = Convert.ToDouble(dataValue.Value);
Interlocked.CompareExchange(ref doubleValue, 0, double.MaxValue);
dataValue.Value = doubleValue + 1;
valueUpdated = true;
}
break;
case BuiltInType.DateTime:
if (variable.ValueRank == ValueRanks.Scalar)
{
dataValue.Value = DateTime.UtcNow;
valueUpdated = true;
}
break;
case BuiltInType.Guid:
if (variable.ValueRank == ValueRanks.Scalar)
{
dataValue.Value = Guid.NewGuid();
valueUpdated = true;
}
break;
case BuiltInType.String:
if (variable.ValueRank == ValueRanks.Scalar)
{
m_aviationAlphabetIndex = (m_aviationAlphabetIndex + 1) % m_aviationAlphabet.Length;
dataValue.Value = m_aviationAlphabet[m_aviationAlphabetIndex];
valueUpdated = true;
}
break;
}
if (valueUpdated)
{
// Save new updated value to data store
WriteFieldData(variable.Name, namespaceIndex, dataValue);
}
}
public FieldMetaDataDragDropObject(FieldMetaData data, object source)
{
_data = data;
_source = source;
}
/// <summary>
/// Initialize fieldsMemberInfo, attachedTags fieldOptionalFlags and fieldsConstraints.
/// </summary>
/// <exception cref="Asn1UserDefinedTypeInconsistent">
/// Thrown when Asn1Field attribute is used not only in fields and properties.
/// </exception>
private void CollectMetadata()
{
//TODO: ensure that only collect once for each derived class, like static member. Cound not find a solution yet.
//Get metadata for fields
MemberInfo[] mis = GetType().GetMembers(
BindingFlags.Instance | BindingFlags.Public | BindingFlags.FlattenHierarchy);
List<MemberInfo> list = new List<MemberInfo>();
foreach (var mi in mis)
{
if (mi.IsDefined(typeof(Asn1Field), true))
{
if (mi.MemberType == MemberTypes.Field ||
mi.MemberType == MemberTypes.Property)
{
list.Add(mi);
}
else
{
//Unreachable. Ensured by the AttributeUsage of Asn1Field.
throw new Asn1UserDefinedTypeInconsistent(ExceptionMessages.UserDefinedTypeInconsistent
+ " Asn1Field attribute could only be used in properties or fields.");
}
}
}
//Sort by Asn1Field.Index, make its order consistent with the ASN.1 definition
MemberInfo[] sortedMetadata = list.OrderBy(mi =>
{
var attrs = mi.GetCustomAttributes(typeof(Asn1Field), true);
if (attrs == null || attrs.Length == 0)
{
throw new Asn1UserDefinedTypeInconsistent(ExceptionMessages.UserDefinedTypeInconsistent + " No Asn1Field is specified.");
}
return (attrs[0] as Asn1Field).Index;
}).ToArray();
fieldsMetaData = new FieldMetaData[sortedMetadata.Length];
for (int i = 0; i < fieldsMetaData.Length; i++)
{
fieldsMetaData[i] = new FieldMetaData(this, sortedMetadata[i]);
}
}
public ExtensionFileMetaData(ExtensionFileType extensionFileType)
: base(extensionFileType)
{
this.extensionFileType = extensionFileType ?? new ExtensionFileType();
Fields = new FieldMetaData(this.extensionFileType?.Coreid, this.extensionFileType?.Field);
}
private static T GetFieldValue <T>(BitReader r, FieldMetaData fieldMeta) where T : struct
{
return(r.ReadValue64(32 - fieldMeta.Bits).GetValue <T>());
}
public CoreFileMetaData(CoreFileType coreFileType) :
base(coreFileType)
{
this.coreFileType = coreFileType ?? new CoreFileType();
Fields = new FieldMetaData(this.coreFileType?.Id, this.coreFileType?.Field);
}
/// <summary>
/// Increment value
/// maxAllowedValue - maximum incremented value before reset value to initial value
/// step - the increment value
/// </summary>
/// <param name="variable"></param>
/// <param name="namespaceIndex"></param>
/// <param name="maxAllowedValue"></param>
/// <param name="step"></param>
private void IncrementValue(FieldMetaData variable, ushort namespaceIndex, long maxAllowedValue = Int32.MaxValue, int step = 0)
{
// Read value to be incremented
DataValue dataValue = m_dataStore.ReadPublishedDataItem(new NodeId(variable.Name, namespaceIndex), Attributes.Value);
if (dataValue.Value == null)
{
return;
}
bool valueUpdated = false;
BuiltInType expectedType = TypeInfo.GetBuiltInType(variable.DataType);
switch (expectedType)
{
case BuiltInType.Boolean:
if (variable.ValueRank == ValueRanks.Scalar)
{
Boolean boolValue = Convert.ToBoolean(dataValue.Value);
dataValue.Value = !boolValue;
valueUpdated = true;
}
break;
case BuiltInType.Byte:
if (variable.ValueRank == ValueRanks.Scalar)
{
Byte byteValue = Convert.ToByte(dataValue.Value);
dataValue.Value = ++byteValue;
valueUpdated = true;
}
break;
case BuiltInType.Int16:
if (variable.ValueRank == ValueRanks.Scalar)
{
Int16 int16Value = Convert.ToInt16(dataValue.Value);
int intIdentifier = int16Value;
Interlocked.CompareExchange(ref intIdentifier, 0, Int16.MaxValue);
dataValue.Value = (Int16)Interlocked.Increment(ref intIdentifier);
valueUpdated = true;
}
break;
case BuiltInType.Int32:
if (variable.ValueRank == ValueRanks.Scalar)
{
Int32 int32Value = Convert.ToInt32(dataValue.Value);
if (step > 0)
{
int32Value += (step - 1);
}
if (int32Value > maxAllowedValue)
{
int32Value = 0;
}
dataValue.Value = Interlocked.Increment(ref int32Value);
valueUpdated = true;
}
break;
case BuiltInType.SByte:
if (variable.ValueRank == ValueRanks.Scalar)
{
SByte sbyteValue = Convert.ToSByte(dataValue.Value);
int intIdentifier = sbyteValue;
Interlocked.CompareExchange(ref intIdentifier, 0, SByte.MaxValue);
dataValue.Value = (SByte)Interlocked.Increment(ref intIdentifier);
valueUpdated = true;
}
break;
case BuiltInType.UInt16:
if (variable.ValueRank == ValueRanks.Scalar)
{
UInt16 uint16Value = Convert.ToUInt16(dataValue.Value);
int intIdentifier = uint16Value;
Interlocked.CompareExchange(ref intIdentifier, 0, UInt16.MaxValue);
dataValue.Value = (UInt16)Interlocked.Increment(ref intIdentifier);
valueUpdated = true;
}
break;
case BuiltInType.UInt32:
if (variable.ValueRank == ValueRanks.Scalar)
{
UInt32 uint32Value = Convert.ToUInt32(dataValue.Value);
long longIdentifier = uint32Value;
Interlocked.CompareExchange(ref longIdentifier, 0, UInt32.MaxValue);
dataValue.Value = (UInt32)Interlocked.Increment(ref longIdentifier);
valueUpdated = true;
}
break;
case BuiltInType.Float:
if (variable.ValueRank == ValueRanks.Scalar)
{
float floatValue = Convert.ToSingle(dataValue.Value);
Interlocked.CompareExchange(ref floatValue, 0, float.MaxValue);
dataValue.Value = ++floatValue;
valueUpdated = true;
}
break;
case BuiltInType.Double:
if (variable.ValueRank == ValueRanks.Scalar)
{
double doubleValue = Convert.ToDouble(dataValue.Value);
Interlocked.CompareExchange(ref doubleValue, 0, double.MaxValue);
dataValue.Value = ++doubleValue;
valueUpdated = true;
}
break;
case BuiltInType.DateTime:
if (variable.ValueRank == ValueRanks.Scalar)
{
dataValue.Value = DateTime.UtcNow;
valueUpdated = true;
}
break;
}
if (valueUpdated)
{
// Save new updated value to data store
WriteFieldData(variable.Name, namespaceIndex, dataValue);
}
}
