/// <inheritdoc/>
public void LoadUaDefinedTypes(ISystemContext context)
{
if (m_uaTypesLoaded)
{
return;
}
NodeStateCollection predefinedNodes = new NodeStateCollection();
var assembly = typeof(ArgumentCollection).GetTypeInfo().Assembly;
predefinedNodes.LoadFromBinaryResource(context, "Opc.Ua.Stack.Generated.Opc.Ua.PredefinedNodes.uanodes", assembly, true);
for (int ii = 0; ii < predefinedNodes.Count; ii++)
{
BaseTypeState type = predefinedNodes[ii] as BaseTypeState;
if (type == null)
{
continue;
}
type.Export(context, m_nodes);
}
m_uaTypesLoaded = true;
}
/// <summary>
/// Loads the UA defined types into the cache.
/// </summary>
/// <param name="context">The context.</param>
public void LoadUaDefinedTypes(ISystemContext context)
{
NodeStateCollection predefinedNodes = new NodeStateCollection();
predefinedNodes.LoadFromBinaryResource(context, "Opc.Ua.Stack.Generated.Opc.Ua.PredefinedNodes.uanodes", typeof(NodeState).Assembly, true);
for (int ii = 0; ii < predefinedNodes.Count; ii++)
{
BaseTypeState type = predefinedNodes[ii] as BaseTypeState;
if (type == null)
{
continue;
}
type.Export(context, m_nodes);
}
}
/// <summary>
/// Recursively adds the types to the type tree.
/// </summary>
protected void AddTypesToTypeTree(BaseTypeState type)
{
if (!NodeId.IsNull(type.SuperTypeId))
{
if (!Server.TypeTree.IsKnown(type.SuperTypeId))
{
AddTypesToTypeTree(type.SuperTypeId);
}
}
if (type.NodeClass != NodeClass.ReferenceType)
{
Server.TypeTree.AddSubtype(type.NodeId, type.SuperTypeId);
}
else
{
Server.TypeTree.AddReferenceSubtype(type.NodeId, type.SuperTypeId, type.BrowseName);
}
}
/// <summary>
/// Imports a node from the set.
/// </summary>
private NodeState Import(ISystemContext context, UANode node)
{
NodeState importedNode = null;
NodeClass nodeClass = NodeClass.Unspecified;
if (node is UAObject)
{
nodeClass = NodeClass.Object;
}
else if (node is UAVariable)
{
nodeClass = NodeClass.Variable;
}
else if (node is UAMethod)
{
nodeClass = NodeClass.Method;
}
else if (node is UAObjectType)
{
nodeClass = NodeClass.ObjectType;
}
else if (node is UAVariableType)
{
nodeClass = NodeClass.VariableType;
}
else if (node is UADataType)
{
nodeClass = NodeClass.DataType;
}
else if (node is UAReferenceType)
{
nodeClass = NodeClass.ReferenceType;
}
else if (node is UAView)
{
nodeClass = NodeClass.View;
}
switch (nodeClass)
{
case NodeClass.Object:
{
UAObject o = (UAObject)node;
BaseObjectState value = new BaseObjectState(null);
value.EventNotifier = o.EventNotifier;
importedNode = value;
break;
}
case NodeClass.Variable:
{
UAVariable o = (UAVariable)node;
NodeId typeDefinitionId = null;
if (node.References != null)
{
for (int ii = 0; ii < node.References.Length; ii++)
{
Opc.Ua.NodeId referenceTypeId = ImportNodeId(node.References[ii].ReferenceType, context.NamespaceUris, true);
bool isInverse = !node.References[ii].IsForward;
Opc.Ua.ExpandedNodeId targetId = ImportExpandedNodeId(node.References[ii].Value, context.NamespaceUris, context.ServerUris);
if (referenceTypeId == ReferenceTypeIds.HasTypeDefinition && !isInverse)
{
typeDefinitionId = Opc.Ua.ExpandedNodeId.ToNodeId(targetId, context.NamespaceUris);
break;
}
}
}
BaseVariableState value = null;
if (typeDefinitionId == Opc.Ua.VariableTypeIds.PropertyType)
{
value = new PropertyState(null);
}
else
{
value = new BaseDataVariableState(null);
}
value.DataType = ImportNodeId(o.DataType, context.NamespaceUris, true);
value.ValueRank = o.ValueRank;
value.ArrayDimensions = ImportArrayDimensions(o.ArrayDimensions);
value.AccessLevelEx = o.AccessLevel;
value.UserAccessLevel = (byte)(o.AccessLevel & 0xFF);
value.MinimumSamplingInterval = o.MinimumSamplingInterval;
value.Historizing = o.Historizing;
if (o.Value != null)
{
XmlDecoder decoder = CreateDecoder(context, o.Value);
TypeInfo typeInfo = null;
value.Value = decoder.ReadVariantContents(out typeInfo);
decoder.Close();
}
importedNode = value;
break;
}
case NodeClass.Method:
{
UAMethod o = (UAMethod)node;
MethodState value = new MethodState(null);
value.Executable = o.Executable;
value.UserExecutable = o.Executable;
value.TypeDefinitionId = ImportNodeId(o.MethodDeclarationId, context.NamespaceUris, true);
importedNode = value;
break;
}
case NodeClass.View:
{
UAView o = (UAView)node;
ViewState value = new ViewState();
value.ContainsNoLoops = o.ContainsNoLoops;
importedNode = value;
break;
}
case NodeClass.ObjectType:
{
UAObjectType o = (UAObjectType)node;
BaseObjectTypeState value = new BaseObjectTypeState();
value.IsAbstract = o.IsAbstract;
importedNode = value;
break;
}
case NodeClass.VariableType:
{
UAVariableType o = (UAVariableType)node;
BaseVariableTypeState value = new BaseDataVariableTypeState();
value.IsAbstract = o.IsAbstract;
value.DataType = ImportNodeId(o.DataType, context.NamespaceUris, true);
value.ValueRank = o.ValueRank;
value.ArrayDimensions = ImportArrayDimensions(o.ArrayDimensions);
if (o.Value != null)
{
XmlDecoder decoder = CreateDecoder(context, o.Value);
TypeInfo typeInfo = null;
value.Value = decoder.ReadVariantContents(out typeInfo);
decoder.Close();
}
importedNode = value;
break;
}
case NodeClass.DataType:
{
UADataType o = (UADataType)node;
DataTypeState value = new DataTypeState();
value.IsAbstract = o.IsAbstract;
Opc.Ua.DataTypeDefinition dataTypeDefinition = Import(o, o.Definition, context.NamespaceUris);
value.DataTypeDefinition = new ExtensionObject(dataTypeDefinition);
value.Purpose = o.Purpose;
value.DataTypeModifier = DataTypeModifier.None;
if (o.Definition != null)
{
if (o.Definition.IsOptionSet)
{
value.DataTypeModifier = DataTypeModifier.OptionSet;
}
else if (o.Definition.IsUnion)
{
value.DataTypeModifier = DataTypeModifier.Union;
}
}
importedNode = value;
break;
}
case NodeClass.ReferenceType:
{
UAReferenceType o = (UAReferenceType)node;
ReferenceTypeState value = new ReferenceTypeState();
value.IsAbstract = o.IsAbstract;
value.InverseName = Import(o.InverseName);
value.Symmetric = o.Symmetric;
importedNode = value;
break;
}
}
importedNode.NodeId = ImportNodeId(node.NodeId, context.NamespaceUris, false);
importedNode.BrowseName = ImportQualifiedName(node.BrowseName, context.NamespaceUris);
importedNode.DisplayName = Import(node.DisplayName);
if (importedNode.DisplayName == null)
{
importedNode.DisplayName = new Ua.LocalizedText(importedNode.BrowseName.Name);
}
importedNode.Description = Import(node.Description);
importedNode.Categories = (node.Category != null && node.Category.Length > 0) ? node.Category : null;
importedNode.ReleaseStatus = node.ReleaseStatus;
importedNode.WriteMask = (AttributeWriteMask)node.WriteMask;
importedNode.UserWriteMask = (AttributeWriteMask)node.UserWriteMask;
importedNode.Extensions = node.Extensions;
if (!String.IsNullOrEmpty(node.SymbolicName))
{
importedNode.SymbolicName = node.SymbolicName;
}
if (node.References != null)
{
BaseInstanceState instance = importedNode as BaseInstanceState;
BaseTypeState type = importedNode as BaseTypeState;
for (int ii = 0; ii < node.References.Length; ii++)
{
Opc.Ua.NodeId referenceTypeId = ImportNodeId(node.References[ii].ReferenceType, context.NamespaceUris, true);
bool isInverse = !node.References[ii].IsForward;
Opc.Ua.ExpandedNodeId targetId = ImportExpandedNodeId(node.References[ii].Value, context.NamespaceUris, context.ServerUris);
if (instance != null)
{
if (referenceTypeId == ReferenceTypeIds.HasModellingRule && !isInverse)
{
instance.ModellingRuleId = Opc.Ua.ExpandedNodeId.ToNodeId(targetId, context.NamespaceUris);
continue;
}
if (referenceTypeId == ReferenceTypeIds.HasTypeDefinition && !isInverse)
{
instance.TypeDefinitionId = Opc.Ua.ExpandedNodeId.ToNodeId(targetId, context.NamespaceUris);
continue;
}
}
if (type != null)
{
if (referenceTypeId == ReferenceTypeIds.HasSubtype && isInverse)
{
type.SuperTypeId = Opc.Ua.ExpandedNodeId.ToNodeId(targetId, context.NamespaceUris);
continue;
}
}
importedNode.AddReference(referenceTypeId, isInverse, targetId);
}
}
return(importedNode);
}
/// <summary>
/// Indexes the well known subtypes.
/// </summary>
private void IndexWellKnownTypes()
{
SystemContext context = new SystemContext();
context.EncodeableFactory = m_session.MessageContext.Factory;
context.NamespaceUris = m_session.NamespaceUris;
context.ServerUris = m_session.ServerUris;
NodeStateCollection predefinedNodes = new NodeStateCollection();
predefinedNodes.LoadFromBinaryResource(context, "Opc.Ua.Stack.Generated.Opc.Ua.PredefinedNodes.uanodes", typeof(NodeState).Assembly, true);
NodeIdDictionary <BaseTypeState> types = new NodeIdDictionary <BaseTypeState>();
// collect the instance declarations for all types.
for (int ii = 0; ii < predefinedNodes.Count; ii++)
{
BaseTypeState type = predefinedNodes[ii] as BaseTypeState;
if (type != null)
{
types.Add(type.NodeId, type);
}
}
// index only those types which are subtypes of BaseEventType.
foreach (BaseTypeState type in types.Values)
{
BaseTypeState subType = type;
BaseTypeState superType = null;
int eventType = 0;
while (subType != null)
{
if (subType.NodeId == Opc.Ua.ObjectTypeIds.ConditionType || subType.SuperTypeId == Opc.Ua.ObjectTypeIds.ConditionType)
{
eventType = OpcRcw.Ae.Constants.CONDITION_EVENT;
}
else if (subType.NodeId == Opc.Ua.ObjectTypeIds.AuditEventType || subType.SuperTypeId == Opc.Ua.ObjectTypeIds.AuditEventType)
{
eventType = OpcRcw.Ae.Constants.TRACKING_EVENT;
}
else if (subType.NodeId == Opc.Ua.ObjectTypeIds.BaseEventType || subType.SuperTypeId == Opc.Ua.ObjectTypeIds.BaseEventType)
{
eventType = OpcRcw.Ae.Constants.SIMPLE_EVENT;
}
// found an event, collect the attribute and index it.
if (eventType != 0)
{
List <AeEventAttribute> declarations = new List <AeEventAttribute>();
Dictionary <string, AeEventAttribute> map = new Dictionary <string, AeEventAttribute>();
ComAeUtils.CollectInstanceDeclarations(
m_session,
this,
type,
null,
declarations,
map);
AeEventCategory declaration = new AeEventCategory();
declaration.TypeId = type.NodeId;
declaration.SuperTypeId = type.SuperTypeId;
declaration.EventType = eventType;
declaration.Description = (LocalizedText.IsNullOrEmpty(type.DisplayName))?type.BrowseName.Name:type.DisplayName.Text;
declaration.Attributes = declarations;
m_eventTypes[declaration.TypeId] = declaration;
break;
}
// follow the tree to the parent.
if (!types.TryGetValue(subType.SuperTypeId, out superType))
{
break;
}
subType = superType;
}
}
// hide the built in attributes.
AeEventCategory category = GetCategory(Opc.Ua.ObjectTypeIds.BaseEventType);
if (category != null)
{
for (int ii = 0; ii < category.Attributes.Count; ii++)
{
switch (category.Attributes[ii].BrowsePathDisplayText)
{
case Opc.Ua.BrowseNames.Message:
case Opc.Ua.BrowseNames.Severity:
case Opc.Ua.BrowseNames.SourceName:
case Opc.Ua.BrowseNames.Time:
case Opc.Ua.BrowseNames.ReceiveTime:
case Opc.Ua.BrowseNames.LocalTime:
{
category.Attributes[ii].Hidden = true;
break;
}
}
}
}
}
