/// <summary>
/// Returns true if the relative path does not specify any elements.
/// </summary>
public static bool IsEmpty(RelativePath relativePath)
{
if (relativePath != null)
{
return relativePath.Elements.Count == 0;
}
return true;
}
/// <summary>
/// Creates an operand that references a component/property of a type.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="nodeId">The node identifier.</param>
/// <param name="relativePath">The relative path.</param>
public AttributeOperand(
FilterContext context,
ExpandedNodeId nodeId,
RelativePath relativePath)
{
m_nodeId = ExpandedNodeId.ToNodeId(nodeId, context.NamespaceUris);
m_browsePath = relativePath;
m_attributeId = Attributes.Value;
m_indexRange = null;
m_alias = null;
}
/// <summary>
/// Constructs an operand from a value.
/// </summary>
/// <param name="nodeId">The node identifier.</param>
/// <param name="browsePaths">The browse paths.</param>
public AttributeOperand(
NodeId nodeId,
IList<QualifiedName> browsePaths)
{
m_nodeId = nodeId;
m_attributeId = Attributes.Value;
m_browsePath = new RelativePath();
for (int ii = 0; ii < browsePaths.Count; ii++)
{
RelativePathElement element = new RelativePathElement();
element.ReferenceTypeId = ReferenceTypeIds.Aggregates;
element.IsInverse = false;
element.IncludeSubtypes = true;
element.TargetName = browsePaths[ii];
m_browsePath.Elements.Add(element);
}
}
/// <summary>
/// Constructs an operand from a value.
/// </summary>
/// <param name="nodeId">The node identifier.</param>
/// <param name="browsePath">The browse path.</param>
public AttributeOperand(
NodeId nodeId,
QualifiedName browsePath)
{
m_nodeId = nodeId;
m_attributeId = Attributes.Value;
m_browsePath = new RelativePath();
RelativePathElement element = new RelativePathElement();
element.ReferenceTypeId = ReferenceTypeIds.Aggregates;
element.IsInverse = false;
element.IncludeSubtypes = true;
element.TargetName = browsePath;
m_browsePath.Elements.Add(element);
}
/// <summary>
/// Parses a relative path formatted as a string.
/// </summary>
public static RelativePath Parse(string browsePath, ITypeTable typeTree)
{
if (typeTree == null) throw new ArgumentNullException("typeTree");
// parse the string.
RelativePathFormatter formatter = RelativePathFormatter.Parse(browsePath);
// 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:
{
parsedElement.ReferenceTypeId = typeTree.FindReferenceType(element.ReferenceTypeName);
break;
}
case RelativePathFormatter.ElementType.InverseReference:
{
parsedElement.ReferenceTypeId = typeTree.FindReferenceType(element.ReferenceTypeName);
parsedElement.IsInverse = true;
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 object the default values.
/// </summary>
public RelativePathFormatter(RelativePath relativePath, ITypeTable typeTree)
{
m_elements = new List<Element>();
if (relativePath != null)
{
foreach (RelativePathElement element in relativePath.Elements)
{
m_elements.Add(new Element(element, typeTree));
}
}
}
/// <summary>
/// Recursively collects the variables in a NodeState and returns a collection of BrowsePaths.
/// </summary>
public void GetBrowsePathFromNodeState(
ISystemContext context,
NodeId rootId,
NodeState parent,
RelativePath parentPath,
BrowsePathCollection browsePaths)
{
List<BaseInstanceState> children = new List<BaseInstanceState>();
parent.GetChildren(context, children);
for (int ii = 0; ii < children.Count; ii++)
{
BaseInstanceState child = children[ii];
BrowsePath browsePath = new BrowsePath();
browsePath.StartingNode = rootId;
browsePath.Handle = child;
if (parentPath != null)
{
browsePath.RelativePath.Elements.AddRange(parentPath.Elements);
}
RelativePathElement element = new RelativePathElement();
element.ReferenceTypeId = child.ReferenceTypeId;
element.IsInverse = false;
element.IncludeSubtypes = false;
element.TargetName = child.BrowseName;
browsePath.RelativePath.Elements.Add(element);
if (child.NodeClass == NodeClass.Variable)
{
browsePaths.Add(browsePath);
}
GetBrowsePathFromNodeState(context, rootId, child, browsePath.RelativePath, browsePaths);
}
}
/// <summary>
/// Reads the historical configuration for the node.
/// </summary>
private HistoricalDataConfigurationState ReadConfiguration()
{
// load the defaults for the historical configuration object.
HistoricalDataConfigurationState configuration = new HistoricalDataConfigurationState(null);
configuration.Definition = new PropertyState<string>(configuration);
configuration.MaxTimeInterval = new PropertyState<double>(configuration);
configuration.MinTimeInterval = new PropertyState<double>(configuration);
configuration.ExceptionDeviation = new PropertyState<double>(configuration);
configuration.ExceptionDeviationFormat = new PropertyState<ExceptionDeviationFormat>(configuration);
configuration.StartOfArchive = new PropertyState<DateTime>(configuration);
configuration.StartOfOnlineArchive = new PropertyState<DateTime>(configuration);
configuration.Create(
m_session.SystemContext,
null,
Opc.Ua.BrowseNames.HAConfiguration,
null,
false);
// get the browse paths to query.
RelativePathElement element = new RelativePathElement();
element.ReferenceTypeId = Opc.Ua.ReferenceTypeIds.HasHistoricalConfiguration;
element.IsInverse = false;
element.IncludeSubtypes = false;
element.TargetName = Opc.Ua.BrowseNames.HAConfiguration;
RelativePath relativePath = new RelativePath();
relativePath.Elements.Add(element);
BrowsePathCollection pathsToTranslate = new BrowsePathCollection();
GetBrowsePathFromNodeState(
m_session.SystemContext,
m_nodeId,
configuration,
relativePath,
pathsToTranslate);
// translate browse paths.
BrowsePathResultCollection results = null;
DiagnosticInfoCollection diagnosticInfos = null;
m_session.TranslateBrowsePathsToNodeIds(
null,
pathsToTranslate,
out results,
out diagnosticInfos);
ClientBase.ValidateResponse(results, pathsToTranslate);
ClientBase.ValidateDiagnosticInfos(diagnosticInfos, pathsToTranslate);
// build list of values to read.
ReadValueIdCollection valuesToRead = new ReadValueIdCollection();
for (int ii = 0; ii < pathsToTranslate.Count; ii++)
{
BaseVariableState variable = (BaseVariableState)pathsToTranslate[ii].Handle;
variable.Value = null;
variable.StatusCode = StatusCodes.BadNotSupported;
if (StatusCode.IsBad(results[ii].StatusCode) || results[ii].Targets.Count == 0)
{
continue;
}
if (results[ii].Targets[0].RemainingPathIndex == UInt32.MaxValue && !results[ii].Targets[0].TargetId.IsAbsolute)
{
variable.NodeId = (NodeId)results[ii].Targets[0].TargetId;
ReadValueId valueToRead = new ReadValueId();
valueToRead.NodeId = variable.NodeId;
valueToRead.AttributeId = Attributes.Value;
valueToRead.Handle = variable;
valuesToRead.Add(valueToRead);
}
}
// read the values.
if (valuesToRead.Count > 0)
{
DataValueCollection values = null;
m_session.Read(
null,
0,
TimestampsToReturn.Neither,
valuesToRead,
out values,
out diagnosticInfos);
ClientBase.ValidateResponse(values, valuesToRead);
ClientBase.ValidateDiagnosticInfos(diagnosticInfos, valuesToRead);
for (int ii = 0; ii < valuesToRead.Count; ii++)
{
BaseVariableState variable = (BaseVariableState)valuesToRead[ii].Handle;
variable.WrappedValue = values[ii].WrappedValue;
variable.StatusCode = values[ii].StatusCode;
}
}
return configuration;
}
/// <summary>
/// Parses a relative path formatted as a string.
/// </summary>
public static RelativePath Parse(string browsePath, ITypeTable typeTree)
{
if (typeTree == null)
{
throw new ArgumentNullException("typeTree");
}
// parse the string.
RelativePathFormatter formatter = RelativePathFormatter.Parse(browsePath);
// 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:
{
parsedElement.ReferenceTypeId = typeTree.FindReferenceType(element.ReferenceTypeName);
break;
}
case RelativePathFormatter.ElementType.InverseReference:
{
parsedElement.ReferenceTypeId = typeTree.FindReferenceType(element.ReferenceTypeName);
parsedElement.IsInverse = true;
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);
}
