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