/// <summary> /// Initializes the instance with its defalt attribute values. /// </summary> protected InstanceNodeModel(NodeClass nodeClass, BaseNodeModel parent) : base(nodeClass) { Parent = parent; if (Parent != null) { ReferenceTypeId = ReferenceTypeIds.HasComponent; } }
/// <summary> /// Convert to stack object /// </summary> /// <param name="nodeModel"></param> /// <param name="context"></param> /// <param name="parent"></param> /// <returns></returns> public static NodeState ToNodeState(this BaseNodeModel nodeModel, ISystemContext context, NodeState parent = null) { NodeState state; switch (nodeModel) { case ViewNodeModel viewState: state = new ViewState { ContainsNoLoops = viewState.ContainsNoLoops ?? false, EventNotifier = viewState.EventNotifier ?? EventNotifiers.None, }; break; case TypeNodeModel typeState: switch (typeState) { case VariableTypeNodeModel variableType: switch (variableType) { case DataVariableTypeNodeModel data: state = new BaseDataVariableTypeState(); break; case PropertyTypeNodeModel property: state = new PropertyTypeState(); break; default: return(null); } var baseVariableTypeState = state as BaseVariableTypeState; baseVariableTypeState.ArrayDimensions = variableType.ArrayDimensions; baseVariableTypeState.DataType = variableType.DataType; baseVariableTypeState.ValueRank = variableType.ValueRank ?? ValueRanks.Scalar; baseVariableTypeState.WrappedValue = variableType.Value ?? Variant.Null; break; case ObjectTypeNodeModel objectType: state = new BaseObjectTypeState(); break; case ReferenceTypeNodeModel referenceType: state = new ReferenceTypeState { Symmetric = referenceType.Symmetric ?? false, InverseName = referenceType.InverseName }; break; case DataTypeNodeModel dataType: state = new DataTypeState { // Definition = dataType.Definition.ToDataTypeDefinition() }; break; default: return(null); } var baseTypeState = state as BaseTypeState; baseTypeState.IsAbstract = typeState.IsAbstract ?? false; break; case InstanceNodeModel instanceState: switch (instanceState) { case VariableNodeModel variable: switch (variable) { case DataVariableNodeModel data: state = new BaseDataVariableState(parent); break; case PropertyNodeModel property: state = new PropertyState(parent); break; default: return(null); } var baseVariableState = state as BaseVariableState; baseVariableState.ArrayDimensions = variable.ArrayDimensions; baseVariableState.DataType = variable.DataType; baseVariableState.ValueRank = variable.ValueRank ?? ValueRanks.Scalar; baseVariableState.Value = variable.Value?.Value; baseVariableState.AccessLevel = variable.AccessLevel ?? AccessLevels.CurrentRead; baseVariableState.UserAccessLevel = variable.UserAccessLevel ?? AccessLevels.CurrentRead; baseVariableState.IsValueType = variable.IsValueType; baseVariableState.Historizing = variable.Historizing ?? false; baseVariableState.MinimumSamplingInterval = variable.MinimumSamplingInterval ?? 0.0; baseVariableState.ModellingRuleId = variable.ModellingRuleId; baseVariableState.NumericId = variable.NumericId; baseVariableState.ReferenceTypeId = variable.ReferenceTypeId; baseVariableState.StatusCode = variable.StatusCode ?? StatusCodes.Good; baseVariableState.Timestamp = variable.Timestamp ?? DateTime.MinValue; baseVariableState.TypeDefinitionId = variable.TypeDefinitionId; break; case ObjectNodeModel obj: state = new BaseObjectState(parent) { EventNotifier = obj.EventNotifier ?? EventNotifiers.None }; break; case MethodNodeModel method: state = new MethodState(parent) { UserExecutable = method.UserExecutable, Executable = method.Executable, MethodDeclarationId = method.MethodDeclarationId }; break; default: return(null); } break; default: return(null); } state.BrowseName = nodeModel.BrowseName; state.Description = nodeModel.Description; state.DisplayName = nodeModel.DisplayName; state.Handle = nodeModel.Handle; state.NodeId = nodeModel.NodeId; state.SymbolicName = nodeModel.SymbolicName; state.WriteMask = nodeModel.WriteMask ?? AttributeWriteMask.None; state.UserWriteMask = nodeModel.UserWriteMask ?? AttributeWriteMask.None; state.Initialized = true; foreach (var child in nodeModel.GetChildren(context)) { state.AddChild(child.ToNodeState(context, state) as BaseInstanceState); } foreach (var reference in nodeModel.References) { state.AddReference(reference.ReferenceTypeId, reference.IsInverse, reference.TargetId); } return(state); }
/// <summary> /// Convert to node attributes /// be encoded. /// </summary> /// <param name="nodeModel"></param> /// <param name="context"></param> /// <returns></returns> public static INodeAttributes ToNodeAttributes(this BaseNodeModel nodeModel, ISystemContext context) { var raw = new NodeAttributeSet(nodeModel.NodeId, context.NamespaceUris) { BrowseName = nodeModel.BrowseName, DisplayName = nodeModel.DisplayName, Description = nodeModel.Description, WriteMask = (uint?)nodeModel.WriteMask, AccessRestrictions = nodeModel.AccessRestrictions, RolePermissions = nodeModel.RolePermissions, UserRolePermissions = nodeModel.UserRolePermissions, UserWriteMask = (uint?)nodeModel.UserWriteMask }; switch (nodeModel) { case ObjectNodeModel o: raw.NodeClass = NodeClass.Object; raw.EventNotifier = o.EventNotifier; break; case VariableNodeModel o: raw.NodeClass = NodeClass.Variable; raw.DataType = o.DataType; raw.ValueRank = o.ValueRank; raw.ArrayDimensions = o.ArrayDimensions; raw.AccessLevel = o.AccessLevel; raw.AccessLevelEx = o.AccessLevel; raw.UserAccessLevel = (byte)o.UserAccessLevel; raw.MinimumSamplingInterval = o.MinimumSamplingInterval; raw.Historizing = o.Historizing; raw.Value = new Variant(o.Value); break; case VariableTypeNodeModel o: raw.NodeClass = NodeClass.VariableType; raw.IsAbstract = o.IsAbstract; raw.DataType = o.DataType; raw.ValueRank = o.ValueRank; raw.ArrayDimensions = o.ArrayDimensions; raw.Value = new Variant(o.Value); break; case MethodNodeModel o: raw.NodeClass = NodeClass.Method; raw.Executable = o.Executable; raw.UserExecutable = o.UserExecutable; break; case ObjectTypeNodeModel o: raw.NodeClass = NodeClass.ObjectType; raw.IsAbstract = o.IsAbstract; break; case DataTypeNodeModel o: raw.NodeClass = NodeClass.DataType; raw.IsAbstract = o.IsAbstract; raw.DataTypeDefinition = new ExtensionObject(o.Definition); break; case ReferenceTypeNodeModel o: raw.NodeClass = NodeClass.ReferenceType; raw.InverseName = o.InverseName; raw.IsAbstract = o.IsAbstract; raw.Symmetric = o.Symmetric; break; case ViewNodeModel o: raw.NodeClass = NodeClass.View; raw.ContainsNoLoops = o.ContainsNoLoops; break; } foreach (var reference in nodeModel.GetAllReferences(context)) { raw.References.Add(reference); } return(raw); }
/// <summary> /// Convert to service object /// </summary> /// <param name="state"></param> /// <param name="context"></param> /// <param name="parent"></param> /// <returns></returns> public static BaseNodeModel ToNodeModel(this NodeState state, ISystemContext context, BaseNodeModel parent = null) { BaseNodeModel nodeModel; switch (state) { case ViewState viewState: nodeModel = new ViewNodeModel { ContainsNoLoops = viewState.ContainsNoLoops.ToNullable(false), EventNotifier = viewState.EventNotifier.ToNullable(EventNotifiers.None), }; break; case BaseTypeState typeState: switch (typeState) { case BaseVariableTypeState variableType: switch (variableType) { case BaseDataVariableTypeState data: nodeModel = new DataVariableTypeNodeModel(); break; case PropertyTypeState property: nodeModel = new PropertyTypeNodeModel(); break; default: return(null); } var baseVariableTypeState = nodeModel as VariableTypeNodeModel; baseVariableTypeState.ArrayDimensions = variableType.ArrayDimensions?.ToArray(); baseVariableTypeState.DataType = variableType.DataType; baseVariableTypeState.ValueRank = variableType.ValueRank.ToNullable(ValueRanks.Scalar); baseVariableTypeState.Value = variableType.WrappedValue; break; case BaseObjectTypeState objectType: nodeModel = new ObjectTypeNodeModel(); break; case ReferenceTypeState referenceType: nodeModel = new ReferenceTypeNodeModel { Symmetric = referenceType.Symmetric.ToNullable(false), InverseName = referenceType.InverseName }; break; case DataTypeState dataType: nodeModel = new DataTypeNodeModel { // Definition = dataType.Definition.ToDataTypeDefinition(), Purpose = Schema.DataTypePurpose.Normal }; break; default: return(null); } var baseTypeState = nodeModel as TypeNodeModel; baseTypeState.IsAbstract = typeState.IsAbstract.ToNullable(false); break; case BaseInstanceState instanceState: switch (instanceState) { case BaseVariableState variable: switch (variable) { case BaseDataVariableState data: nodeModel = new DataVariableNodeModel(parent); break; case PropertyState property: nodeModel = new PropertyNodeModel(parent); break; default: return(null); } var baseVariableState = nodeModel as VariableNodeModel; baseVariableState.ArrayDimensions = variable.ArrayDimensions.ToArray(); baseVariableState.DataType = variable.DataType; baseVariableState.ValueRank = variable.ValueRank.ToNullable(ValueRanks.Scalar); baseVariableState.Value = variable.WrappedValue; baseVariableState.AccessLevel = variable.AccessLevel.ToNullable(AccessLevels.CurrentRead); baseVariableState.UserAccessLevel = variable.UserAccessLevel.ToNullable(AccessLevels.CurrentRead); baseVariableState.IsValueType = variable.IsValueType; baseVariableState.Historizing = variable.Historizing.ToNullable(false); baseVariableState.MinimumSamplingInterval = variable.MinimumSamplingInterval.ToNullable(0.0); baseVariableState.ModellingRuleId = variable.ModellingRuleId; baseVariableState.NumericId = variable.NumericId; baseVariableState.ReferenceTypeId = variable.ReferenceTypeId; baseVariableState.StatusCode = variable.StatusCode.ToNullable(StatusCodes.Good); baseVariableState.Timestamp = variable.Timestamp.ToNullable(DateTime.MinValue); baseVariableState.TypeDefinitionId = variable.TypeDefinitionId; break; case BaseObjectState obj: nodeModel = new ObjectNodeModel(parent) { EventNotifier = obj.EventNotifier.ToNullable(EventNotifiers.None) }; break; case MethodState method: nodeModel = new MethodNodeModel(parent) { UserExecutable = method.UserExecutable, Executable = method.Executable, MethodDeclarationId = method.MethodDeclarationId, }; break; default: return(null); } break; default: return(null); } nodeModel.BrowseName = state.BrowseName; nodeModel.Description = state.Description; nodeModel.DisplayName = state.DisplayName; nodeModel.Handle = state.Handle; nodeModel.NodeId = state.NodeId; nodeModel.SymbolicName = state.SymbolicName; nodeModel.WriteMask = state.WriteMask.ToNullable(AttributeWriteMask.None); nodeModel.UserWriteMask = state.UserWriteMask.ToNullable(AttributeWriteMask.None); var children = new List <BaseInstanceState>(); state.GetChildren(context, children); foreach (var child in children) { nodeModel.AddChild(child.ToNodeModel(context, nodeModel) as InstanceNodeModel); } var references = new List <IReference>(); state.GetReferences(context, references); foreach (var reference in references) { nodeModel.AddReference(reference.ReferenceTypeId, reference.IsInverse, reference.TargetId); } return(nodeModel); }
/// <summary> /// Create object node /// </summary> public ObjectNodeModel(BaseNodeModel parent = null) : base(NodeClass.Object, parent) { }
/// <summary> /// Create method node /// </summary> public MethodNodeModel(BaseNodeModel parent = null) : base(NodeClass.Method, parent) { Executable = true; UserExecutable = true; }
/// <inheritdoc/> public virtual void Decode(IDecoder decoder) { decoder.PushNamespace(Namespaces.OpcUa); decoder.PushNamespace(Namespaces.OpcUaXsd); Node = CreateModel(decoder.ReadString(kTypeFieldName)); Node.NodeId = decoder.ReadNodeId(nameof(Node.NodeId)); Node.SymbolicName = decoder.ReadString(nameof(Node.SymbolicName)); Node.BrowseName = decoder.ReadQualifiedName(nameof(Node.BrowseName)); Node.DisplayName = decoder.ReadLocalizedText(nameof(Node.DisplayName)); Node.Description = decoder.ReadLocalizedText(nameof(Node.Description)); Node.WriteMask = decoder.ReadEnumerated <AttributeWriteMask>(nameof(Node.WriteMask)); Node.UserWriteMask = decoder.ReadEnumerated <AttributeWriteMask>(nameof(Node.UserWriteMask)); switch (Node) { case InstanceNodeModel instanceState: instanceState.ReferenceTypeId = decoder.ReadNodeId(nameof(instanceState.ReferenceTypeId)); instanceState.TypeDefinitionId = decoder.ReadNodeId(nameof(instanceState.TypeDefinitionId)); instanceState.ModellingRuleId = decoder.ReadNodeId(nameof(instanceState.ModellingRuleId)); instanceState.NumericId = decoder.ReadUInt32(nameof(instanceState.NumericId)); switch (instanceState) { case ObjectNodeModel objectState: objectState.EventNotifier = decoder.ReadByte(nameof(objectState.EventNotifier)); break; case VariableNodeModel variableState: variableState.Value = decoder.ReadVariant(nameof(variableState.Value)); variableState.StatusCode = decoder.ReadStatusCode(nameof(variableState.StatusCode)); variableState.DataType = decoder.ReadNodeId(nameof(variableState.DataType)); variableState.ValueRank = decoder.ReadInt32(nameof(variableState.ValueRank)); variableState.ArrayDimensions = decoder.ReadUInt32Array(nameof(variableState.ArrayDimensions))?.ToArray(); variableState.AccessLevel = decoder.ReadByte(nameof(variableState.AccessLevel)); variableState.AccessLevelEx = decoder.ReadUInt32(nameof(variableState.AccessLevelEx)); variableState.UserAccessLevel = decoder.ReadByte(nameof(variableState.UserAccessLevel)); variableState.MinimumSamplingInterval = decoder.ReadDouble(nameof(variableState.MinimumSamplingInterval)); variableState.Historizing = decoder.ReadBoolean(nameof(variableState.Historizing)); break; case MethodNodeModel methodState: methodState.Executable = decoder.ReadBoolean(nameof(methodState.Executable)); methodState.UserExecutable = decoder.ReadBoolean(nameof(methodState.UserExecutable)); break; } break; case TypeNodeModel typeState: typeState.IsAbstract = decoder.ReadBoolean(nameof(typeState.IsAbstract)); typeState.SuperTypeId = decoder.ReadNodeId(nameof(typeState.SuperTypeId)); switch (Node) { case VariableTypeNodeModel variableTypeState: variableTypeState.Value = decoder.ReadVariant(nameof(variableTypeState.Value)); variableTypeState.DataType = decoder.ReadNodeId(nameof(variableTypeState.DataType)); variableTypeState.ValueRank = decoder.ReadInt32(nameof(variableTypeState.ValueRank)); variableTypeState.ArrayDimensions = decoder.ReadUInt32Array(nameof(variableTypeState.ArrayDimensions))?.ToArray(); break; case ReferenceTypeNodeModel refTypeState: refTypeState.Symmetric = decoder.ReadBoolean(nameof(refTypeState.Symmetric)); refTypeState.InverseName = decoder.ReadLocalizedText(nameof(refTypeState.InverseName)); break; case DataTypeNodeModel dataTypeState: var definitionType = GetDefinitionType( decoder.ReadString(kDefinitionTypeFieldName)); dataTypeState.Definition = (DataTypeDefinition)decoder.ReadEncodeable( nameof(dataTypeState.Definition), definitionType); dataTypeState.Purpose = decoder.ReadEnumerated <Schema.DataTypePurpose>( nameof(dataTypeState.Purpose)); break; case ObjectTypeNodeModel objectTypeState: break; } break; case ViewNodeModel viewState: viewState.EventNotifier = decoder.ReadByte(nameof(viewState.EventNotifier)); viewState.ContainsNoLoops = decoder.ReadBoolean(nameof(viewState.ContainsNoLoops)); break; } var ctx = decoder.Context.ToSystemContext(); var children = decoder.ReadEncodeableArray <EncodeableNodeModel>(kChildrenFieldName); foreach (var child in children.Select(n => n.Node).OfType <InstanceNodeModel>()) { Node.AddChild(child); } var references = decoder.ReadEncodeableArray <EncodeableReferenceModel>(kReferencesFieldName); Node.AddReferences(references.Select(r => r.Reference).ToList()); decoder.PopNamespace(); decoder.PopNamespace(); }
/// <summary> /// Create encodeable node state /// </summary> /// <param name="state"></param> public EncodeableNodeModel(BaseNodeModel state) { Node = state; }
/// <summary> /// Create variable node /// </summary> /// <param name="parent"></param> protected VariableNodeModel(BaseNodeModel parent = null) : base(NodeClass.Variable, parent) { }
/// <summary> /// Create property state. /// </summary> public PropertyNodeModel(BaseNodeModel parent = null) : base(parent) { }
/// <summary> /// Create data variable node /// </summary> public DataVariableNodeModel(BaseNodeModel parent = null) : base(parent) { }