/// <summary>
/// Returns the node ids for a set of relative paths.
/// </summary>
/// <param name="session">An open session with the server to use.</param>
/// <param name="startNodeId">The starting node for the relative paths.</param>
/// <param name="namespacesUris">The namespace URIs referenced by the relative paths.</param>
/// <param name="relativePaths">The relative paths.</param>
/// <returns>A collection of local nodes.</returns>
public static List<NodeId> TranslateBrowsePaths(
Session session,
NodeId startNodeId,
NamespaceTable namespacesUris,
params string[] relativePaths)
{
// build the list of browse paths to follow by parsing the relative paths.
BrowsePathCollection browsePaths = new BrowsePathCollection();
if (relativePaths != null)
{
for (int ii = 0; ii < relativePaths.Length; ii++)
{
BrowsePath browsePath = new BrowsePath();
// The relative paths used indexes in the namespacesUris table. These must be
// converted to indexes used by the server. An error occurs if the relative path
// refers to a namespaceUri that the server does not recognize.
// The relative paths may refer to ReferenceType by their BrowseName. The TypeTree object
// allows the parser to look up the server's NodeId for the ReferenceType.
browsePath.RelativePath = RelativePath.Parse(
relativePaths[ii],
session.TypeTree,
namespacesUris,
session.NamespaceUris);
browsePath.StartingNode = startNodeId;
browsePaths.Add(browsePath);
}
}
// make the call to the server.
BrowsePathResultCollection results;
DiagnosticInfoCollection diagnosticInfos;
ResponseHeader responseHeader = session.TranslateBrowsePathsToNodeIds(
null,
browsePaths,
out results,
out diagnosticInfos);
// ensure that the server returned valid results.
Session.ValidateResponse(results, browsePaths);
Session.ValidateDiagnosticInfos(diagnosticInfos, browsePaths);
// collect the list of node ids found.
List<NodeId> nodes = new List<NodeId>();
for (int ii = 0; ii < results.Count; ii++)
{
// check if the start node actually exists.
if (StatusCode.IsBad(results[ii].StatusCode))
{
nodes.Add(null);
continue;
}
// an empty list is returned if no node was found.
if (results[ii].Targets.Count == 0)
{
nodes.Add(null);
continue;
}
// Multiple matches are possible, however, the node that matches the type model is the
// one we are interested in here. The rest can be ignored.
BrowsePathTarget target = results[ii].Targets[0];
if (target.RemainingPathIndex != UInt32.MaxValue)
{
nodes.Add(null);
continue;
}
// The targetId is an ExpandedNodeId because it could be node in another server.
// The ToNodeId function is used to convert a local NodeId stored in a ExpandedNodeId to a NodeId.
nodes.Add(ExpandedNodeId.ToNodeId(target.TargetId, session.NamespaceUris));
}
// return whatever was found.
return nodes;
}
/// <summary>
/// Initializes the object with default values.
/// </summary>
/// <param name="namespaceUris">The namespace URIs.</param>
public TypeTable(NamespaceTable namespaceUris)
{
m_namespaceUris = namespaceUris;
m_referenceTypes = new SortedDictionary<QualifiedName,TypeInfo>();
m_nodes = new NodeIdDictionary<TypeInfo>();
m_encodings = new NodeIdDictionary<TypeInfo>();
}
/// <summary>
/// Creates an empty factory.
/// </summary>
/// <param name="namespaceUris">The namespace uris.</param>
/// <param name="factory">The factory.</param>
public BindingFactory(NamespaceTable namespaceUris, EncodeableFactory factory)
{
m_bindings = new Dictionary<string, Type>();
AddDefaultBindings(m_bindings);
m_namespaceUris = namespaceUris;
m_factory = factory;
}
private ServiceMessageContext(bool shared) : this()
{
m_maxStringLength = UInt16.MaxValue;
m_maxByteStringLength = UInt16.MaxValue*16;
m_maxArrayLength = UInt16.MaxValue;
m_maxMessageSize = UInt16.MaxValue*32;
m_namespaceUris = new NamespaceTable(shared);
m_serverUris = new StringTable(shared);
m_factory = EncodeableFactory.GlobalFactory;
}
public TestDataSystem(ITestDataSystemCallback callback, NamespaceTable namespaceUris, StringTable serverUris)
{
m_callback = callback;
m_minimumSamplingInterval = Int32.MaxValue;
m_monitoredNodes = new Dictionary<uint,BaseVariableState>();
m_generator = new Opc.Ua.Test.DataGenerator(null);
m_generator.NamespaceUris = namespaceUris;
m_generator.ServerUris = serverUris;
m_historyArchive = new HistoryArchive();
}
public DashboardMappingData(Session uaConnection, string nodeId, string nodeIdJson, string typeNodeIdJson, bool useType, string[] interfacesIds,
string dashboard, string existingDashboard, string perspective, Opc.Ua.NamespaceTable nsTable)
{
UaConnection = uaConnection;
NodeId = nodeId;
NodeIdJson = nodeIdJson;
TypeNodeIdJson = typeNodeIdJson;
UseType = useType;
InterfacesIds = interfacesIds;
Dashboard = dashboard;
Perspective = perspective;
ExisingDashboard = existingDashboard;
NsTable = nsTable;
}
public cacheDBTest()
{
string json_config = @"{
nodesDatabase:{
isInMemory:true, filename:'pollo.dat', juno:'bul'
},
nodesLoader:{
filename:'nodeset.xml'
}
}";
j = JObject.Parse(json_config);
cDB = new cacheDB(j);
Opc.Ua.NamespaceTable nt = new Opc.Ua.NamespaceTable();
nt.Append("http://www.siemens.com/simatic-s7-opcua");
UANodeConverter ua = new UANodeConverter(j, nt);
ua.fillCacheDB(cDB);
}
/// <summary>
/// Initializes the tables used to map namespace and server uris during encoding.
/// </summary>
/// <param name="namespaceUris">The namespaces URIs referenced by the data being encoded.</param>
/// <param name="serverUris">The server URIs referenced by the data being encoded.</param>
public void SetMappingTables(NamespaceTable namespaceUris, StringTable serverUris)
{
m_namespaceMappings = null;
if (namespaceUris != null && m_context.NamespaceUris != null)
{
m_namespaceMappings = namespaceUris.CreateMapping(m_context.NamespaceUris, false);
}
m_serverMappings = null;
if (serverUris != null && m_context.ServerUris != null)
{
m_serverMappings = serverUris.CreateMapping(m_context.ServerUris, false);
}
}
/// <summary>
/// Returns the id of the default data type node for the instance.
/// </summary>
protected override NodeId GetDefaultDataTypeId(NamespaceTable namespaceUris)
{
return Opc.Ua.NodeId.Create(Opc.Ua.DataTypes.BaseDataType, Opc.Ua.Namespaces.OpcUa, namespaceUris);
}
/// <summary>
/// Returns the id of the default type definition node for the instance.
/// </summary>
/// <param name="namespaceUris">The namespace uris.</param>
/// <returns></returns>
protected virtual NodeId GetDefaultTypeDefinitionId(NamespaceTable namespaceUris)
{
return null;
}
/// <summary>
/// Updates the path to use the indexes from the target table.
/// </summary>
/// <param name="currentTable">The NamespaceTable which the RelativePathString currently references</param>
/// <param name="targetTable">The NamespaceTable which the RelativePathString should reference</param>
public void TranslateNamespaceIndexes(NamespaceTable currentTable, NamespaceTable targetTable)
{
// build mapping table.
int[] mappings = new int[currentTable.Count];
mappings[0] = 0;
// copy mappings.
string[] uris = new string[mappings.Length];
for (int ii = 1; ii < mappings.Length; ii++)
{
uris[ii] = currentTable.GetString((uint)ii);
if (uris[ii] != null)
{
mappings[ii] = targetTable.GetIndex(uris[ii]);
}
}
// update each element.
foreach (Element element in m_elements)
{
QualifiedName qname = element.ReferenceTypeName;
if (qname != null && qname.NamespaceIndex > 0)
{
if (qname.NamespaceIndex < mappings.Length && mappings[qname.NamespaceIndex] > 0)
{
element.ReferenceTypeName = new QualifiedName(qname.Name, (ushort)mappings[qname.NamespaceIndex]);
}
}
qname = element.TargetName;
if (qname != null && qname.NamespaceIndex > 0)
{
if (qname.NamespaceIndex < mappings.Length && mappings[qname.NamespaceIndex] > 0)
{
element.TargetName = new QualifiedName(qname.Name, (ushort)mappings[qname.NamespaceIndex]);
}
}
}
}
/// <summary>
/// Parses a string representing a relative path and translates the namespace indexes.
/// </summary>
/// <remarks>
/// Parses a string representing a relative path.
/// </remarks>
/// <exception cref="ServiceResultException">Thrown if any errors occur during parsing</exception>
public static RelativePathFormatter Parse(string textToParse, NamespaceTable currentTable, NamespaceTable targetTable)
{
RelativePathFormatter path = Parse(textToParse);
if (path != null)
{
path.TranslateNamespaceIndexes(currentTable, targetTable);
}
return(path);
}
/// <summary>
/// Returns the id of the default type definition node for the instance.
/// </summary>
protected override NodeId GetDefaultTypeDefinitionId(NamespaceTable namespaceUris)
{
return Opc.Ua.NodeId.Create(Opc.Ua.Fdi7.ObjectTypes.ISA100_Wireless, Opc.Ua.Fdi7.Namespaces.OpcUaFdi7, namespaceUris);
}
/// <summary>
/// Exports a namespace index.
/// </summary>
private ushort ImportNamespaceIndex(ushort namespaceIndex, NamespaceTable namespaceUris)
{
// nothing special required for indexes 0 and 1.
if (namespaceIndex < 1)
{
return namespaceIndex;
}
// return a bad value if parameters are bad.
if (namespaceUris == null || this.NamespaceUris == null || this.NamespaceUris.Length <= namespaceIndex - 1)
{
return UInt16.MaxValue;
}
// find or append uri.
return namespaceUris.GetIndexOrAppend(this.NamespaceUris[namespaceIndex - 1]);
}
/// <summary>
/// Imports a ExpandedNodeId
/// </summary>
private Opc.Ua.ExpandedNodeId ImportExpandedNodeId(string source, NamespaceTable namespaceUris, StringTable serverUris)
{
if (String.IsNullOrEmpty(source))
{
return Opc.Ua.ExpandedNodeId.Null;
}
// parse the node.
Opc.Ua.ExpandedNodeId nodeId = Opc.Ua.ExpandedNodeId.Parse(source);
if (nodeId.ServerIndex <= 0 && nodeId.NamespaceIndex <= 0 && String.IsNullOrEmpty(nodeId.NamespaceUri))
{
return nodeId;
}
uint serverIndex = ImportServerIndex(nodeId.ServerIndex, serverUris);
ushort namespaceIndex = ImportNamespaceIndex(nodeId.NamespaceIndex, namespaceUris);
if (serverIndex > 0)
{
string namespaceUri = nodeId.NamespaceUri;
if (String.IsNullOrEmpty(nodeId.NamespaceUri))
{
namespaceUri = namespaceUris.GetString(namespaceIndex);
}
nodeId = new Opc.Ua.ExpandedNodeId(nodeId.Identifier, 0, namespaceUri, serverIndex);
return nodeId;
}
nodeId = new Opc.Ua.ExpandedNodeId(nodeId.Identifier, namespaceIndex, null, 0);
return nodeId;
}
/// <summary>
/// Parses a relative path formatted as a string.
/// </summary>
public static RelativePath Parse(
string browsePath,
ITypeTable typeTree,
NamespaceTable currentTable,
NamespaceTable targetTable)
{
// parse the string.
RelativePathFormatter formatter = RelativePathFormatter.Parse(browsePath, currentTable, targetTable);
// convert the browse names to node ids.
RelativePath relativePath = new RelativePath();
foreach (RelativePathFormatter.Element element in formatter.Elements)
{
RelativePathElement parsedElement = new RelativePathElement();
parsedElement.ReferenceTypeId = null;
parsedElement.IsInverse = false;
parsedElement.IncludeSubtypes = element.IncludeSubtypes;
parsedElement.TargetName = element.TargetName;
switch (element.ElementType)
{
case RelativePathFormatter.ElementType.AnyHierarchical:
{
parsedElement.ReferenceTypeId = ReferenceTypeIds.HierarchicalReferences;
break;
}
case RelativePathFormatter.ElementType.AnyComponent:
{
parsedElement.ReferenceTypeId = ReferenceTypeIds.Aggregates;
break;
}
case RelativePathFormatter.ElementType.ForwardReference:
case RelativePathFormatter.ElementType.InverseReference:
{
if (typeTree == null)
{
throw new InvalidOperationException("Cannot parse path with reference names without a type table.");
}
parsedElement.ReferenceTypeId = typeTree.FindReferenceType(element.ReferenceTypeName);
parsedElement.IsInverse = element.ElementType == RelativePathFormatter.ElementType.InverseReference;
break;
}
}
if (NodeId.IsNull(parsedElement.ReferenceTypeId))
{
throw ServiceResultException.Create(
StatusCodes.BadSyntaxError,
"Could not convert BrowseName to a ReferenceTypeId: {0}",
element.ReferenceTypeName);
}
relativePath.Elements.Add(parsedElement);
}
return(relativePath);
}
/// <summary>
/// Initializes the context.
/// </summary>
/// <param name="namespaceUris">The namespace URIs.</param>
/// <param name="typeTree">The type tree.</param>
public FilterContext(NamespaceTable namespaceUris, ITypeTable typeTree)
:
this(namespaceUris, typeTree, (IList <string>)null)
{
}
/// <summary>
/// Reads the schema information from a XML document.
/// </summary>
public void LoadFromXml(ISystemContext context, Stream istrm, bool updateTables)
{
ServiceMessageContext messageContext = new ServiceMessageContext();
messageContext.NamespaceUris = context.NamespaceUris;
messageContext.ServerUris = context.ServerUris;
messageContext.Factory = context.EncodeableFactory;
using (XmlReader reader = XmlReader.Create(istrm, Utils.DefaultXmlReaderSettings()))
{
XmlQualifiedName root = new XmlQualifiedName("ListOfNodeState", Namespaces.OpcUaXsd);
XmlDecoder decoder = new XmlDecoder(null, reader, messageContext);
NamespaceTable namespaceUris = new NamespaceTable();
if (!decoder.LoadStringTable("NamespaceUris", "NamespaceUri", namespaceUris))
{
namespaceUris = null;
}
// update namespace table.
if (updateTables)
{
if (namespaceUris != null && context.NamespaceUris != null)
{
for (int ii = 0; ii < namespaceUris.Count; ii++)
{
context.NamespaceUris.GetIndexOrAppend(namespaceUris.GetString((uint)ii));
}
}
}
StringTable serverUris = new StringTable();
if (!decoder.LoadStringTable("ServerUris", "ServerUri", context.ServerUris))
{
serverUris = null;
}
// update server table.
if (updateTables)
{
if (serverUris != null && context.ServerUris != null)
{
for (int ii = 0; ii < serverUris.Count; ii++)
{
context.ServerUris.GetIndexOrAppend(serverUris.GetString((uint)ii));
}
}
}
// set mapping.
decoder.SetMappingTables(namespaceUris, serverUris);
decoder.PushNamespace(Namespaces.OpcUaXsd);
NodeState state = NodeState.LoadNode(context, decoder);
while (state != null)
{
this.Add(state);
state = NodeState.LoadNode(context, decoder);
}
decoder.Close();
}
}
/// <summary>
/// Reads the schema information from a XML document.
/// </summary>
public void LoadFromBinary(ISystemContext context, Stream istrm, bool updateTables)
{
ServiceMessageContext messageContext = new ServiceMessageContext();
messageContext.NamespaceUris = context.NamespaceUris;
messageContext.ServerUris = context.ServerUris;
messageContext.Factory = context.EncodeableFactory;
using (BinaryDecoder decoder = new BinaryDecoder(istrm, messageContext))
{
// check if a namespace table was provided.
NamespaceTable namespaceUris = new NamespaceTable();
if (!decoder.LoadStringTable(namespaceUris))
{
namespaceUris = null;
}
// update namespace table.
if (updateTables)
{
if (namespaceUris != null && context.NamespaceUris != null)
{
for (int ii = 0; ii < namespaceUris.Count; ii++)
{
context.NamespaceUris.GetIndexOrAppend(namespaceUris.GetString((uint)ii));
}
}
}
// check if a server uri table was provided.
StringTable serverUris = new StringTable();
if (namespaceUris != null && namespaceUris.Count > 1)
{
serverUris.Append(namespaceUris.GetString(1));
}
if (!decoder.LoadStringTable(serverUris))
{
serverUris = null;
}
// update server table.
if (updateTables)
{
if (serverUris != null && context.ServerUris != null)
{
for (int ii = 0; ii < serverUris.Count; ii++)
{
context.ServerUris.GetIndexOrAppend(serverUris.GetString((uint)ii));
}
}
}
// setup the mappings to use during decoding.
decoder.SetMappingTables(namespaceUris, serverUris);
int count = decoder.ReadInt32(null);
for (int ii = 0; ii < count; ii++)
{
NodeState state = NodeState.LoadNode(context, decoder);
this.Add(state);
}
}
}
/// <summary>
/// Returns the id of the default type definition node for the instance.
/// </summary>
protected override NodeId GetDefaultTypeDefinitionId(NamespaceTable namespaceUris)
{
return(ObjectTypes.BaseObjectType);
}
/// <summary>
/// Imports a NodeId
/// </summary>
private Opc.Ua.NodeId ImportNodeId(string source, NamespaceTable namespaceUris, bool lookupAlias)
{
if (String.IsNullOrEmpty(source))
{
return Opc.Ua.NodeId.Null;
}
// parse the string.
Opc.Ua.NodeId nodeId = Opc.Ua.NodeId.Parse(source);
if (nodeId.NamespaceIndex > 0)
{
ushort namespaceIndex = ImportNamespaceIndex(nodeId.NamespaceIndex, namespaceUris);
nodeId = new Opc.Ua.NodeId(nodeId.Identifier, namespaceIndex);
}
return nodeId;
}
/// <summary>
/// Returns the id of the default type definition node for the instance.
/// </summary>
protected override NodeId GetDefaultTypeDefinitionId(NamespaceTable namespaceUris)
{
return Opc.Ua.NodeId.Create(Boiler.ObjectTypes.ValveType, Boiler.Namespaces.Boiler, namespaceUris);
}
/// <summary>
/// Imports a QualifiedName
/// </summary>
private Opc.Ua.QualifiedName ImportQualifiedName(string source, NamespaceTable namespaceUris)
{
if (String.IsNullOrEmpty(source))
{
return Opc.Ua.QualifiedName.Null;
}
Opc.Ua.QualifiedName qname = Opc.Ua.QualifiedName.Parse(source);
if (qname.NamespaceIndex > 0)
{
ushort namespaceIndex = ImportNamespaceIndex(qname.NamespaceIndex, namespaceUris);
qname = new Opc.Ua.QualifiedName(qname.Name, namespaceIndex);
}
return qname;
}
/// <summary>
/// Returns the id of the default type definition node for the instance.
/// </summary>
protected override NodeId GetDefaultTypeDefinitionId(NamespaceTable namespaceUris)
{
return Opc.Ua.NodeId.Create(Opc.Ua.Fdi7.ObjectTypes.ServerCommunicationGENERICDeviceType, Opc.Ua.Fdi7.Namespaces.OpcUaFdi7, namespaceUris);
}
/// <summary>
/// Creates an decoder to restore Variant values.
/// </summary>
private XmlDecoder CreateDecoder(ISystemContext context, XmlElement source)
{
ServiceMessageContext messageContext = new ServiceMessageContext();
messageContext.NamespaceUris = context.NamespaceUris;
messageContext.ServerUris = context.ServerUris;
messageContext.Factory = context.EncodeableFactory;
XmlDecoder decoder = new XmlDecoder(source, messageContext);
NamespaceTable namespaceUris = new NamespaceTable();
if (NamespaceUris != null)
{
for (int ii = 0; ii < NamespaceUris.Length; ii++)
{
namespaceUris.Append(NamespaceUris[ii]);
}
}
StringTable serverUris = new StringTable();
if (ServerUris != null)
{
serverUris.Append(context.ServerUris.GetString(0));
for (int ii = 0; ii < ServerUris.Length; ii++)
{
serverUris.Append(ServerUris[ii]);
}
}
decoder.SetMappingTables(namespaceUris, serverUris);
return decoder;
}
/// <summary>
/// Parses a relative path formatted as a string.
/// </summary>
public static RelativePath Parse(
string browsePath,
ITypeTable typeTree,
NamespaceTable currentTable,
NamespaceTable targetTable)
{
// parse the string.
RelativePathFormatter formatter = RelativePathFormatter.Parse(browsePath, currentTable, targetTable);
// convert the browse names to node ids.
RelativePath relativePath = new RelativePath();
foreach (RelativePathFormatter.Element element in formatter.Elements)
{
RelativePathElement parsedElement = new RelativePathElement();
parsedElement.ReferenceTypeId = null;
parsedElement.IsInverse = false;
parsedElement.IncludeSubtypes = element.IncludeSubtypes;
parsedElement.TargetName = element.TargetName;
switch (element.ElementType)
{
case RelativePathFormatter.ElementType.AnyHierarchical:
{
parsedElement.ReferenceTypeId = ReferenceTypeIds.HierarchicalReferences;
break;
}
case RelativePathFormatter.ElementType.AnyComponent:
{
parsedElement.ReferenceTypeId = ReferenceTypeIds.Aggregates;
break;
}
case RelativePathFormatter.ElementType.ForwardReference:
case RelativePathFormatter.ElementType.InverseReference:
{
if (typeTree == null)
{
throw new InvalidOperationException("Cannot parse path with reference names without a type table.");
}
parsedElement.ReferenceTypeId = typeTree.FindReferenceType(element.ReferenceTypeName);
parsedElement.IsInverse = element.ElementType == RelativePathFormatter.ElementType.InverseReference;
break;
}
}
if (NodeId.IsNull(parsedElement.ReferenceTypeId))
{
throw ServiceResultException.Create(
StatusCodes.BadSyntaxError,
"Could not convert BrowseName to a ReferenceTypeId: {0}",
element.ReferenceTypeName);
}
relativePath.Elements.Add(parsedElement);
}
return relativePath;
}
/// <summary>
/// Returns the id of the default type definition node for the instance.
/// </summary>
protected override NodeId GetDefaultTypeDefinitionId(NamespaceTable namespaceUris)
{
return Opc.Ua.NodeId.Create(Opc.Ua.Fdi7.ObjectTypes.GenericProtocol, Opc.Ua.Fdi7.Namespaces.OpcUaFdi7, namespaceUris);
}
/// <summary>
/// Updates the namespace table with URI used in the relative path.
/// </summary>
/// <param name="currentTable">The current table.</param>
/// <param name="targetTable">The target table.</param>
public void UpdateNamespaceTable(NamespaceTable currentTable, NamespaceTable targetTable)
{
// build mapping table.
int[] mappings = new int[currentTable.Count];
mappings[0] = 0;
if (mappings.Length > 0)
{
mappings[1] = 1;
}
// ensure a placeholder for the local namespace.
if (targetTable.Count <= 1)
{
targetTable.Append("---");
}
string[] uris = new string[mappings.Length];
for (int ii = 2; ii < mappings.Length; ii++)
{
uris[ii] = currentTable.GetString((uint)ii);
if (uris[ii] != null)
{
mappings[ii] = targetTable.GetIndex(uris[ii]);
}
}
// update each element.
foreach (Element element in m_elements)
{
// check reference type name.
QualifiedName qname = element.ReferenceTypeName;
if (qname != null && qname.NamespaceIndex > 1)
{
if (qname.NamespaceIndex < mappings.Length)
{
if (mappings[qname.NamespaceIndex] == -1)
{
mappings[qname.NamespaceIndex] = targetTable.GetIndexOrAppend(uris[qname.NamespaceIndex]);
}
}
}
// check target name.
qname = element.TargetName;
if (qname != null && qname.NamespaceIndex > 1)
{
if (qname.NamespaceIndex < mappings.Length)
{
if (mappings[qname.NamespaceIndex] == -1)
{
mappings[qname.NamespaceIndex] = targetTable.GetIndexOrAppend(uris[qname.NamespaceIndex]);
}
}
}
}
}
/// <summary>
/// Returns the id of the default type definition node for the instance.
/// </summary>
protected override NodeId GetDefaultTypeDefinitionId(NamespaceTable namespaceUris)
{
return Opc.Ua.NodeId.Create(Opc.Ua.Fdi7.ObjectTypes.ConnectionPoint_Foundation_H1, Opc.Ua.Fdi7.Namespaces.OpcUaFdi7, namespaceUris);
}
/// <summary>
/// Returns the id of the default type definition node for the instance.
/// </summary>
protected override NodeId GetDefaultTypeDefinitionId(NamespaceTable namespaceUris)
{
return Opc.Ua.NodeId.Create(TutorialModel.ObjectTypes.GenericSensorType, TutorialModel.Namespaces.Tutorial, namespaceUris);
}
/// <summary>
/// Updates the namespace table with URI used in the relative path.
/// </summary>
/// <param name="currentTable">The current table.</param>
/// <param name="targetTable">The target table.</param>
public void UpdateNamespaceTable(NamespaceTable currentTable, NamespaceTable targetTable)
{
// build mapping table.
int[] mappings = new int[currentTable.Count];
mappings[0] = 0;
if (mappings.Length > 0)
{
mappings[1] = 1;
}
// ensure a placeholder for the local namespace.
if (targetTable.Count <= 1)
{
targetTable.Append("---");
}
string[] uris = new string[mappings.Length];
for (int ii = 2; ii < mappings.Length; ii++)
{
uris[ii] = currentTable.GetString((uint)ii);
if (uris[ii] != null)
{
mappings[ii] = targetTable.GetIndex(uris[ii]);
}
}
// update each element.
foreach (Element element in m_elements)
{
// check reference type name.
QualifiedName qname = element.ReferenceTypeName;
if (qname != null && qname.NamespaceIndex > 1)
{
if (qname.NamespaceIndex < mappings.Length)
{
if (mappings[qname.NamespaceIndex] == -1)
{
mappings[qname.NamespaceIndex] = targetTable.GetIndexOrAppend(uris[qname.NamespaceIndex]);
}
}
}
// check target name.
qname = element.TargetName;
if (qname != null && qname.NamespaceIndex > 1)
{
if (qname.NamespaceIndex < mappings.Length)
{
if (mappings[qname.NamespaceIndex] == -1)
{
mappings[qname.NamespaceIndex] = targetTable.GetIndexOrAppend(uris[qname.NamespaceIndex]);
}
}
}
}
}
/// <summary>
/// Updates the application after connecting to or disconnecting from the server.
/// </summary>
private void Server_ConnectComplete(object sender, EventArgs e)
{
try
{
m_session = ConnectServerCTRL.Session;
if (m_session == null)
{
StartBTN.Enabled = false;
return;
}
// set a suitable initial state.
if (m_session != null && !m_connectedOnce)
{
m_connectedOnce = true;
}
// this client has built-in knowledge of the information model used by the server.
NamespaceTable wellKnownNamespaceUris = new NamespaceTable();
wellKnownNamespaceUris.Append(Namespaces.Methods);
string[] browsePaths = new string[]
{
"1:My Process/1:State",
"1:My Process",
"1:My Process/1:Start"
};
List<NodeId> nodes = ClientUtils.TranslateBrowsePaths(
m_session,
ObjectIds.ObjectsFolder,
wellKnownNamespaceUris,
browsePaths);
// subscribe to the state if available.
if (nodes.Count > 0 && !NodeId.IsNull(nodes[0]))
{
m_subscription = new Subscription();
m_subscription.PublishingEnabled = true;
m_subscription.PublishingInterval = 1000;
m_subscription.Priority = 1;
m_subscription.KeepAliveCount = 10;
m_subscription.LifetimeCount = 20;
m_subscription.MaxNotificationsPerPublish = 1000;
m_session.AddSubscription(m_subscription);
m_subscription.Create();
MonitoredItem monitoredItem = new MonitoredItem();
monitoredItem.StartNodeId = nodes[0];
monitoredItem.AttributeId = Attributes.Value;
monitoredItem.Notification += new MonitoredItemNotificationEventHandler(MonitoredItem_Notification);
m_subscription.AddItem(monitoredItem);
m_subscription.ApplyChanges();
}
// save the object/method
if (nodes.Count > 2)
{
m_objectNode = nodes[1];
m_methodNode = nodes[2];
}
InitialStateTB.Text = "1";
FinalStateTB.Text = "100";
StartBTN.Enabled = true;
}
catch (Exception exception)
{
ClientUtils.HandleException(this.Text, exception);
}
}
/// <summary>
/// Parses a string representing a relative path and translates the namespace indexes.
/// </summary>
/// <remarks>
/// Parses a string representing a relative path.
/// </remarks>
/// <exception cref="ServiceResultException">Thrown if any errors occur during parsing</exception>
public static RelativePathFormatter Parse(string textToParse, NamespaceTable currentTable, NamespaceTable targetTable)
{
RelativePathFormatter path = Parse(textToParse);
if (path != null)
{
path.TranslateNamespaceIndexes(currentTable, targetTable);
}
return path;
}
/// <summary>
/// Initializes the context.
/// </summary>
/// <param name="namespaceUris">The namespace URIs.</param>
/// <param name="typeTree">The type tree.</param>
/// <param name="context">The context.</param>
public FilterContext(NamespaceTable namespaceUris, ITypeTable typeTree, IOperationContext context)
{
if (namespaceUris == null) throw new ArgumentNullException("namespaceUris");
if (typeTree == null) throw new ArgumentNullException("typeTree");
m_namespaceUris = namespaceUris;
m_typeTree = typeTree;
m_context = context;
}
/// <summary>
/// Returns a namespace table with all of the URIs defined.
/// </summary>
/// <remarks>
/// This table is was used to create any relative paths in the model design.
/// </remarks>
public static NamespaceTable GetNamespaceTable()
{
FieldInfo[] fields = typeof(Namespaces).GetFields(BindingFlags.Public | BindingFlags.Static);
NamespaceTable namespaceTable = new NamespaceTable();
foreach (FieldInfo field in fields)
{
string namespaceUri = (string)field.GetValue(typeof(Namespaces));
if (namespaceTable.GetIndex(namespaceUri) == -1)
{
namespaceTable.Append(namespaceUri);
}
}
return namespaceTable;
}
/// <summary>
/// Initializes the context.
/// </summary>
/// <param name="namespaceUris">The namespace URIs.</param>
/// <param name="typeTree">The type tree.</param>
public FilterContext(NamespaceTable namespaceUris, ITypeTable typeTree)
:
this(namespaceUris, typeTree, (IList<string>)null)
{
}
/// <summary>
/// Returns the id of the default type definition node for the instance.
/// </summary>
protected override NodeId GetDefaultTypeDefinitionId(NamespaceTable namespaceUris)
{
return Opc.Ua.NodeId.Create(MemoryBuffer.ObjectTypes.MemoryBufferType, MemoryBuffer.Namespaces.MemoryBuffer, namespaceUris);
}
/// <summary>
/// Initializes the context.
/// </summary>
/// <param name="namespaceUris">The namespace URIs.</param>
/// <param name="typeTree">The type tree.</param>
/// <param name="preferredLocales">The preferred locales.</param>
public FilterContext(NamespaceTable namespaceUris, ITypeTable typeTree, IList<string> preferredLocales)
{
if (namespaceUris == null) throw new ArgumentNullException("namespaceUris");
if (typeTree == null) throw new ArgumentNullException("typeTree");
m_namespaceUris = namespaceUris;
m_typeTree = typeTree;
m_context = null;
m_preferredLocales = preferredLocales;
}
/// <summary>
/// Returns the id of the default type definition node for the instance.
/// </summary>
protected override NodeId GetDefaultTypeDefinitionId(NamespaceTable namespaceUris)
{
return Opc.Ua.NodeId.Create(FileSystem.ObjectTypes.AreaType, FileSystem.Namespaces.FileSystem, namespaceUris);
}
/// <summary>
/// Returns the id of the default type definition node for the instance.
/// </summary>
/// <param name="namespaceUris">The namespace uris.</param>
/// <returns></returns>
protected virtual NodeId GetDefaultTypeDefinitionId(NamespaceTable namespaceUris)
{
return(null);
}
