/// <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>
/// Returns the BuiltInType type for the DataTypeId.
/// </summary>
public static BuiltInType GetBuiltInType(NodeId datatypeId, ITypeTable typeTree)
{
return TypeInfo.GetBuiltInType(datatypeId, typeTree);
}
/// <summary>
/// Formats the relative path as a string.
/// </summary>
public string Format(ITypeTable typeTree)
{
RelativePathFormatter formatter = new RelativePathFormatter(this, typeTree);
return formatter.ToString();
}
/// <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>
/// Initializes the object from a RelativePathElement
/// </summary>
public Element(RelativePathElement element, ITypeTable typeTree)
{
if (element == null) throw new ArgumentNullException("element");
if (typeTree == null) throw new ArgumentNullException("typeTree");
m_referenceTypeName = null;
m_targetName = element.TargetName;
m_elementType = RelativePathFormatter.ElementType.ForwardReference;
m_includeSubtypes = element.IncludeSubtypes;
if (!element.IsInverse && element.IncludeSubtypes)
{
if (element.ReferenceTypeId == ReferenceTypeIds.HierarchicalReferences)
{
m_elementType = RelativePathFormatter.ElementType.AnyHierarchical;
}
else if (element.ReferenceTypeId == ReferenceTypeIds.Aggregates)
{
m_elementType = RelativePathFormatter.ElementType.AnyComponent;
}
else
{
m_referenceTypeName = typeTree.FindReferenceTypeName(element.ReferenceTypeId);
}
}
else
{
if (element.IsInverse)
{
m_elementType = RelativePathFormatter.ElementType.InverseReference;
}
m_referenceTypeName = typeTree.FindReferenceTypeName(element.ReferenceTypeId);
}
}
/// <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>
/// 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 supertype for the Node if one exists.
/// </summary>
/// <param name="typeTree">The type tree.</param>
/// <returns>The supertype for the Node if one exists.</returns>
/// <remarks>
/// Includes subtypes of HasSubtype if typeTree != null.
/// </remarks>
public ExpandedNodeId GetSuperType(ITypeTable typeTree)
{
if (m_referenceTable != null)
{
return m_referenceTable.FindTarget(ReferenceTypeIds.HasSubtype, true, typeTree != null, typeTree, 0);
}
return null;
}
/// <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 random value of the specified built-in type.
/// </summary>
public object GetRandom(NodeId dataType, int valueRank, IList <uint> arrayDimensions, ITypeTable typeTree)
{
BuiltInType expectedType = TypeInfo.GetBuiltInType(dataType, typeTree);
// calculate total number of dimensions.
int dimensions = 0;
switch (valueRank)
{
case ValueRanks.Any:
{
if (arrayDimensions != null && arrayDimensions.Count > 0)
{
dimensions = arrayDimensions.Count;
break;
}
dimensions = this.GetRandomRange(0, 1);
break;
}
case ValueRanks.ScalarOrOneDimension:
{
dimensions = this.GetRandomRange(0, 1);
break;
}
case ValueRanks.OneOrMoreDimensions:
{
if (arrayDimensions != null && arrayDimensions.Count > 0)
{
dimensions = arrayDimensions.Count;
break;
}
dimensions = this.GetRandomRange(1, 1);
break;
}
case ValueRanks.Scalar:
{
dimensions = 0;
break;
}
default:
{
dimensions = valueRank;
break;
}
}
// return a random scalar.
if (dimensions == 0)
{
if (expectedType == BuiltInType.Variant)
{
// randomly choose a built-in type.
BuiltInType builtInType = BuiltInType.Variant;
while (builtInType == BuiltInType.Variant || builtInType == BuiltInType.DataValue)
{
builtInType = (BuiltInType)m_random.NextInt32((int)BuiltInType.Variant);
}
return(GetRandomVariant(builtInType, false));
}
return(GetRandom(expectedType));
}
// calculate the length of each dimension.
int[] actualDimensions = new int[dimensions];
for (int ii = 0; ii < dimensions; ii++)
{
if (arrayDimensions != null && arrayDimensions.Count > ii)
{
actualDimensions[ii] = (int)arrayDimensions[ii];
}
if (actualDimensions[ii] == 0)
{
actualDimensions[ii] = m_random.NextInt32(m_maxArrayLength);
}
}
// create an array.
Array output = TypeInfo.CreateArray(expectedType, actualDimensions);
// generate random values for each element in the array.
int length = output.Length;
int[] indexes = new int[actualDimensions.Length];
for (int ii = 0; ii < length; ii++)
{
int divisor = output.Length;
for (int jj = 0; jj < indexes.Length; jj++)
{
divisor /= actualDimensions[jj];
indexes[jj] = (ii / divisor) % actualDimensions[jj];
}
object value = GetRandom(dataType, ValueRanks.Scalar, null, typeTree);
if (value != null)
{
if (expectedType == BuiltInType.Guid)
{
value = new Uuid((Guid)value);
}
output.SetValue(value, indexes);
}
}
// return array value.
return(output);
}
/// <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 BuiltInType type for the DataTypeId.
/// </summary>
public static BuiltInType GetBuiltInType(NodeId datatypeId, ITypeTable typeTree)
{
return(TypeInfo.GetBuiltInType(datatypeId, typeTree));
}
/// <summary>
/// Updates the browse element with the properties return in the read results.
/// </summary>
/// <param name="typeTree">The type tree.</param>
/// <param name="element">The element.</param>
/// <param name="nodesToRead">The nodes to read.</param>
/// <param name="values">The values.</param>
/// <param name="nodeClass">The node class - passed only if all of the information in the ReferenceDescription is available.</param>
/// <param name="onlyEssentialProperties">If true the only properties essential for browing were fetched.</param>
/// <param name="first">The first.</param>
/// <returns></returns>
private bool UpdateBrowseElement(
ITypeTable typeTree,
BrowseElement element,
ReadValueIdCollection nodesToRead,
DataValueCollection values,
NodeClass nodeClass,
bool onlyEssentialProperties,
int first)
{
// check for a valid range within the collection.
if (first < 0 || first >= nodesToRead.Count)
{
return false;
}
if (nodeClass == NodeClass.Unspecified)
{
// verify node class.
NodeClass actualNodeClass = (NodeClass)values[first++].GetValue<int>((int)NodeClass.Unspecified);
if (actualNodeClass != NodeClass.Variable && actualNodeClass != NodeClass.Object)
{
return false;
}
element.NodeClass = actualNodeClass;
// verify browse name.
QualifiedName browseName = values[first++].GetValue<QualifiedName>(null);
if (QualifiedName.IsNull(browseName))
{
return false;
}
element.BrowseName = element.UaBrowseName = m_mapper.GetLocalBrowseName(browseName);
// verify display name.
LocalizedText displayName = values[first++].GetValue<LocalizedText>(null);
if (LocalizedText.IsNullOrEmpty(displayName))
{
return false;
}
element.BrowseName = displayName.Text;
}
if (!onlyEssentialProperties)
{
// check if long description exists.
LocalizedText description = values[first++].GetValue<LocalizedText>(null);
if (!LocalizedText.IsNullOrEmpty(description))
{
element.UaDescription = description.Text;
}
else
{
element.UaDescription = "";
}
}
// update the masks.
SetElementMasks(element);
// nothing more to do.
if (nodeClass == NodeClass.Object)
{
return true;
}
// verify data type.
NodeId dataTypeId = values[first++].GetValue<NodeId>(null);
if (dataTypeId == null && element.NodeClass == NodeClass.Variable)
{
return false;
}
int valueRank = values[first++].GetValue<int>(ValueRanks.Scalar);
// update data type information.
if (dataTypeId != null)
{
element.BuiltInType = DataTypes.GetBuiltInType(dataTypeId, typeTree);
element.DataTypeId = m_mapper.GetLocalItemId(dataTypeId);
element.ValueRank = valueRank;
element.CanonicalDataType = (short)ComUtils.GetVarType(new TypeInfo(element.BuiltInType, element.ValueRank));
}
if (!onlyEssentialProperties)
{
// update scan rate.
element.ScanRate = (float)values[first++].GetValue<double>(MinimumSamplingIntervals.Indeterminate);
// update access rights.
byte userAccessLevel = values[first++].GetValue<byte>(0);
if ((userAccessLevel & AccessLevels.CurrentRead) != 0)
{
element.AccessRights |= OpcRcw.Da.Constants.OPC_READABLE;
}
if ((userAccessLevel & AccessLevels.CurrentWrite) != 0)
{
element.AccessRights |= OpcRcw.Da.Constants.OPC_WRITEABLE;
}
if ((userAccessLevel & AccessLevels.HistoryRead) != 0)
{
element.IsHistoricalItem = true;
}
// cache the latest value.
DataValue value = values[first++];
if (element.NodeClass == NodeClass.Variable)
{
element.LastValue = m_mapper.GetLocalDataValue(value);
}
// update HighEU and LowEU
element.EuType = (int)OpcRcw.Da.OPCEUTYPE.OPC_NOENUM;
element.HighEU = Double.MaxValue;
element.LowEU = Double.MaxValue;
if (element.ReferencesByName.ContainsKey(Opc.Ua.BrowseNames.EURange))
{
Range euRange = values[first++].GetValue<Range>(null);
if (euRange != null)
{
element.EuType = (int)OpcRcw.Da.OPCEUTYPE.OPC_ANALOG;
element.HighEU = euRange.High;
element.LowEU = euRange.Low;
}
}
// update HighIR and LowIR
element.HighIR = Double.MaxValue;
element.LowIR = Double.MaxValue;
if (element.ReferencesByName.ContainsKey(Opc.Ua.BrowseNames.InstrumentRange))
{
Range instrumentRange = values[first++].GetValue<Range>(null);
if (instrumentRange != null)
{
element.HighIR = instrumentRange.High;
element.LowIR = instrumentRange.Low;
}
}
// update EngineeringUnits
element.EngineeringUnits = null;
if (element.ReferencesByName.ContainsKey(Opc.Ua.BrowseNames.EngineeringUnits))
{
EUInformation engineeringUnits = values[first++].GetValue<EUInformation>(null);
if (engineeringUnits != null && engineeringUnits.DisplayName != null)
{
element.EngineeringUnits = engineeringUnits.DisplayName.Text;
}
}
// update EUInfo
element.EuInfo = null;
if (element.ReferencesByName.ContainsKey(Opc.Ua.BrowseNames.EnumStrings))
{
LocalizedText[] enumStrings = values[first++].GetValue<LocalizedText[]>(null);
if (enumStrings != null)
{
string[] strings = new string[enumStrings.Length];
for (int ii = 0; ii < enumStrings.Length; ii++)
{
if (enumStrings[ii] != null)
{
strings[ii] = enumStrings[ii].Text;
}
}
element.EuType = (int)OpcRcw.Da.OPCEUTYPE.OPC_ENUMERATED;
element.EuInfo = strings;
}
}
// update CloseLabel
element.CloseLabel = null;
if (element.ReferencesByName.ContainsKey(Opc.Ua.BrowseNames.TrueState))
{
LocalizedText trueState = values[first++].GetValue<LocalizedText>(null);
if (trueState != null)
{
element.CloseLabel = trueState.Text;
}
}
// update OpenLabel
element.OpenLabel = null;
if (element.ReferencesByName.ContainsKey(Opc.Ua.BrowseNames.FalseState))
{
LocalizedText falseState = values[first++].GetValue<LocalizedText>(null);
if (falseState != null)
{
element.OpenLabel = falseState.Text;
}
}
// update TimeZone
element.TimeZone = Int32.MaxValue;
if (element.ReferencesByName.ContainsKey(Opc.Ua.BrowseNames.LocalTime))
{
TimeZoneDataType timeZone = values[first++].GetValue<TimeZoneDataType>(null);
if (timeZone != null)
{
element.TimeZone = timeZone.Offset;
}
}
}
return true;
}
/// <summary>
/// Parses a relative path formatted as a string.
/// </summary>
public static RelativePath Parse(string browsePath, ITypeTable typeTree)
{
if (typeTree == null)
{
throw new ArgumentNullException(nameof(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>
/// Formats the relative path as a string.
/// </summary>
public string Format(ITypeTable typeTree)
{
RelativePathFormatter formatter = new RelativePathFormatter(this, typeTree);
return(formatter.ToString());
}
/// <summary>
/// Get random data
/// </summary>
/// <param name="dataType"></param>
/// <param name="valueRank"></param>
/// <param name="arrayDimensions"></param>
/// <param name="typeTree"></param>
/// <returns></returns>
public object GetRandom(NodeId dataType, int valueRank, IList <uint> arrayDimensions,
ITypeTable typeTree)
{
var builtInType = Ua.TypeInfo.GetBuiltInType(dataType, typeTree);
var num = 0;
switch (valueRank)
{
case -2:
num = (arrayDimensions == null || arrayDimensions.Count <= 0) ?
GetRandomRange(0, 1) : arrayDimensions.Count;
break;
case -3:
num = GetRandomRange(0, 1);
break;
case 0:
num = (arrayDimensions == null || arrayDimensions.Count <= 0) ?
GetRandomRange(1, 1) : arrayDimensions.Count;
break;
case -1:
num = 0;
break;
default:
num = valueRank;
break;
}
if (num == 0)
{
if (builtInType == BuiltInType.Variant)
{
var builtInType2 = BuiltInType.Variant;
while (builtInType2 == BuiltInType.Variant || builtInType2 == BuiltInType.DataValue)
{
builtInType2 = (BuiltInType)_random.NextInt32(24);
}
return(GetRandomVariant(builtInType2, isArray: false));
}
return(GetRandom(builtInType));
}
var array = new int[num];
for (var i = 0; i < num; i++)
{
if (arrayDimensions != null && arrayDimensions.Count > i)
{
array[i] = (int)arrayDimensions[i];
}
while (array[i] == 0)
{
array[i] = _random.NextInt32(MaxArrayLength);
}
}
var array2 = Ua.TypeInfo.CreateArray(builtInType, array);
var length = array2.Length;
var array3 = new int[array.Length];
for (var j = 0; j < length; j++)
{
var num2 = array2.Length;
for (var k = 0; k < array3.Length; k++)
{
num2 /= array[k];
array3[k] = j / num2 % array[k];
}
var obj = GetRandom(dataType, -1, null, typeTree);
if (obj != null)
{
if (builtInType == BuiltInType.Guid)
{
obj = new Uuid((Guid)obj);
}
array2.SetValue(obj, array3);
}
}
return(array2);
}
