/// <summary>
/// Translates all namespace/server indexes in attributes or references and returns a copy of the node.
/// </summary>
/// <param name="nodeToImport">The node to import.</param>
/// <param name="namespaceUris">The namespace URIs.</param>
/// <param name="serverUris">The server URIs.</param>
/// <returns>Translated copy of the node.</returns>
/// <remarks>
/// Only imports references stored in the References collection.
/// </remarks>
public Node Copy(Node nodeToImport, NamespaceTable namespaceUris, StringTable serverUris)
{
Node node = Node.Copy(nodeToImport);
node.NodeId = Translate(nodeToImport.NodeId, namespaceUris, m_namespaceUris);
node.BrowseName = Translate(nodeToImport.BrowseName, namespaceUris, m_namespaceUris);
VariableNode variableToImport = nodeToImport as VariableNode;
if (variableToImport != null)
{
VariableNode variable = (VariableNode)node;
variable.DataType = Translate(variableToImport.DataType, namespaceUris, m_namespaceUris);
if (variableToImport.Value.Value != null)
{
variable.Value = new Variant(ImportValue(variableToImport.Value.Value, namespaceUris, serverUris));
}
}
VariableTypeNode variableTypeToImport = nodeToImport as VariableTypeNode;
if (variableTypeToImport != null)
{
VariableTypeNode variableType = (VariableTypeNode)node;
variableType.DataType = Translate(variableTypeToImport.DataType, namespaceUris, m_namespaceUris);
if (variableTypeToImport.Value.Value != null)
{
variableType.Value =
new Variant(ImportValue(variableTypeToImport.Value.Value, namespaceUris, serverUris));
}
}
foreach (ReferenceNode referenceToImport in nodeToImport.References)
{
ReferenceNode reference = new ReferenceNode();
reference.ReferenceTypeId =
Translate(referenceToImport.ReferenceTypeId, namespaceUris, m_namespaceUris);
reference.IsInverse = referenceToImport.IsInverse;
reference.TargetId = Translate(referenceToImport.TargetId, namespaceUris, serverUris, m_namespaceUris,
m_serverUris);
node.References.Add(reference);
}
return(node);
}
/// <summary>
/// Adds a node to the set after translating all namespace/server indexes in attributes or references.
/// </summary>
/// <param name="nodeToExport">The node to export.</param>
/// <param name="namespaceUris">The namespace URIs.</param>
/// <param name="serverUris">The server URIs.</param>
/// <returns>The node.</returns>
/// <remarks>
/// Does not add references.
/// </remarks>
public Node Add(ILocalNode nodeToExport, NamespaceTable namespaceUris, StringTable serverUris)
{
Node node = Node.Copy(nodeToExport);
node.NodeId = Translate(nodeToExport.NodeId, m_namespaceUris, namespaceUris);
node.BrowseName = Translate(nodeToExport.BrowseName, m_namespaceUris, namespaceUris);
VariableNode variableToExport = nodeToExport as VariableNode;
if (variableToExport != null)
{
VariableNode variableNode = (VariableNode)node;
object value = TranslateValue(variableNode.Value.Value, namespaceUris, serverUris);
variableNode.Value = new Variant(value);
variableNode.DataType = Translate(variableToExport.DataType, m_namespaceUris, namespaceUris);
}
VariableTypeNode variableTypeToExport = nodeToExport as VariableTypeNode;
if (variableTypeToExport != null)
{
VariableTypeNode variableTypeNode = (VariableTypeNode)node;
object value = TranslateValue(variableTypeNode.Value.Value, namespaceUris, serverUris);
variableTypeNode.Value = new Variant(value);
variableTypeNode.DataType = Translate(variableTypeToExport.DataType, m_namespaceUris, namespaceUris);
}
foreach (IReference referenceToExport in nodeToExport.References)
{
ReferenceNode reference = new ReferenceNode();
reference.ReferenceTypeId =
Translate(referenceToExport.ReferenceTypeId, m_namespaceUris, namespaceUris);
reference.IsInverse = referenceToExport.IsInverse;
reference.TargetId = Translate(referenceToExport.TargetId, m_namespaceUris, m_serverUris, namespaceUris,
serverUris);
node.References.Add(reference);
}
Add(node);
return(node);
}
/// <summary>
/// Exports a copy of the node to a node table.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="node">The node.</param>
protected override void Export(ISystemContext context, Node node)
{
base.Export(context, node);
VariableTypeNode variableTypeNode = node as VariableTypeNode;
if (variableTypeNode != null)
{
variableTypeNode.Value = new Variant(Utils.Clone(this.Value));
variableTypeNode.DataType = this.DataType;
variableTypeNode.ValueRank = this.ValueRank;
variableTypeNode.ArrayDimensions = null;
if (this.ArrayDimensions != null)
{
variableTypeNode.ArrayDimensions = new UInt32Collection(this.ArrayDimensions);
}
}
}
public Node ReadNode(NodeId nodeId)
{
// build list of attributes.
SortedDictionary<uint,DataValue> attributes = new SortedDictionary<uint,DataValue>();
attributes.Add(Attributes.NodeId, null);
attributes.Add(Attributes.NodeClass, null);
attributes.Add(Attributes.BrowseName, null);
attributes.Add(Attributes.DisplayName, null);
attributes.Add(Attributes.Description, null);
attributes.Add(Attributes.WriteMask, null);
attributes.Add(Attributes.UserWriteMask, null);
attributes.Add(Attributes.DataType, null);
attributes.Add(Attributes.ValueRank, null);
attributes.Add(Attributes.ArrayDimensions, null);
attributes.Add(Attributes.AccessLevel, null);
attributes.Add(Attributes.UserAccessLevel, null);
attributes.Add(Attributes.Historizing, null);
attributes.Add(Attributes.MinimumSamplingInterval, null);
attributes.Add(Attributes.EventNotifier, null);
attributes.Add(Attributes.Executable, null);
attributes.Add(Attributes.UserExecutable, null);
attributes.Add(Attributes.IsAbstract, null);
attributes.Add(Attributes.InverseName, null);
attributes.Add(Attributes.Symmetric, null);
attributes.Add(Attributes.ContainsNoLoops, null);
// build list of values to read.
ReadValueIdCollection itemsToRead = new ReadValueIdCollection();
foreach (uint attributeId in attributes.Keys)
{
ReadValueId itemToRead = new ReadValueId();
itemToRead.NodeId = nodeId;
itemToRead.AttributeId = attributeId;
itemsToRead.Add(itemToRead);
}
// read from server.
DataValueCollection values = null;
DiagnosticInfoCollection diagnosticInfos = null;
ResponseHeader responseHeader = Read(
null,
0,
TimestampsToReturn.Neither,
itemsToRead,
out values,
out diagnosticInfos);
ClientBase.ValidateResponse(values, itemsToRead);
ClientBase.ValidateDiagnosticInfos(diagnosticInfos, itemsToRead);
// process results.
int? nodeClass = null;
for (int ii = 0; ii < itemsToRead.Count; ii++)
{
uint attributeId = itemsToRead[ii].AttributeId;
// the node probably does not exist if the node class is not found.
if (attributeId == Attributes.NodeClass)
{
if (!DataValue.IsGood(values[ii]))
{
throw ServiceResultException.Create(values[ii].StatusCode, ii, diagnosticInfos, responseHeader.StringTable);
}
// check for valid node class.
nodeClass = values[ii].Value as int?;
if (nodeClass == null)
{
throw ServiceResultException.Create(StatusCodes.BadUnexpectedError, "Node does not have a valid value for NodeClass: {0}.", values[ii].Value);
}
}
else
{
if (!DataValue.IsGood(values[ii]))
{
// check for unsupported attributes.
if (values[ii].StatusCode == StatusCodes.BadAttributeIdInvalid)
{
continue;
}
// all supported attributes must be readable.
if (attributeId != Attributes.Value)
{
throw ServiceResultException.Create(values[ii].StatusCode, ii, diagnosticInfos, responseHeader.StringTable);
}
}
}
attributes[attributeId] = values[ii];
}
Node node = null;
DataValue value = null;
switch ((NodeClass)nodeClass.Value)
{
default:
{
throw ServiceResultException.Create(StatusCodes.BadUnexpectedError, "Node does not have a valid value for NodeClass: {0}.", nodeClass.Value);
}
case NodeClass.Object:
{
ObjectNode objectNode = new ObjectNode();
value = attributes[Attributes.EventNotifier];
if (value == null)
{
throw ServiceResultException.Create(StatusCodes.BadUnexpectedError, "Object does not support the EventNotifier attribute.");
}
objectNode.EventNotifier = (byte)attributes[Attributes.EventNotifier].GetValue(typeof(byte));
node = objectNode;
break;
}
case NodeClass.ObjectType:
{
ObjectTypeNode objectTypeNode = new ObjectTypeNode();
value = attributes[Attributes.IsAbstract];
if (value == null)
{
throw ServiceResultException.Create(StatusCodes.BadUnexpectedError, "ObjectType does not support the IsAbstract attribute.");
}
objectTypeNode.IsAbstract = (bool)attributes[Attributes.IsAbstract].GetValue(typeof(bool));
node = objectTypeNode;
break;
}
case NodeClass.Variable:
{
VariableNode variableNode = new VariableNode();
// DataType Attribute
value = attributes[Attributes.DataType];
if (value == null)
{
throw ServiceResultException.Create(StatusCodes.BadUnexpectedError, "Variable does not support the DataType attribute.");
}
variableNode.DataType = (NodeId)attributes[Attributes.DataType].GetValue(typeof(NodeId));
// ValueRank Attribute
value = attributes[Attributes.ValueRank];
if (value == null)
{
throw ServiceResultException.Create(StatusCodes.BadUnexpectedError, "Variable does not support the ValueRank attribute.");
}
variableNode.ValueRank = (int)attributes[Attributes.ValueRank].GetValue(typeof(int));
// ArrayDimensions Attribute
value = attributes[Attributes.ArrayDimensions];
if (value != null)
{
if (value.Value == null)
{
variableNode.ArrayDimensions = new uint[0];
}
else
{
variableNode.ArrayDimensions = (uint[])value.GetValue(typeof(uint[]));
}
}
// AccessLevel Attribute
value = attributes[Attributes.AccessLevel];
if (value == null)
{
throw ServiceResultException.Create(StatusCodes.BadUnexpectedError, "Variable does not support the AccessLevel attribute.");
}
variableNode.AccessLevel = (byte)attributes[Attributes.AccessLevel].GetValue(typeof(byte));
// UserAccessLevel Attribute
value = attributes[Attributes.UserAccessLevel];
if (value == null)
{
throw ServiceResultException.Create(StatusCodes.BadUnexpectedError, "Variable does not support the UserAccessLevel attribute.");
}
variableNode.UserAccessLevel = (byte)attributes[Attributes.UserAccessLevel].GetValue(typeof(byte));
// Historizing Attribute
value = attributes[Attributes.Historizing];
if (value == null)
{
throw ServiceResultException.Create(StatusCodes.BadUnexpectedError, "Variable does not support the Historizing attribute.");
}
variableNode.Historizing = (bool)attributes[Attributes.Historizing].GetValue(typeof(bool));
// MinimumSamplingInterval Attribute
value = attributes[Attributes.MinimumSamplingInterval];
if (value != null)
{
variableNode.MinimumSamplingInterval = Convert.ToDouble(attributes[Attributes.MinimumSamplingInterval].Value);
}
node = variableNode;
break;
}
case NodeClass.VariableType:
{
VariableTypeNode variableTypeNode = new VariableTypeNode();
// IsAbstract Attribute
value = attributes[Attributes.IsAbstract];
if (value == null)
{
throw ServiceResultException.Create(StatusCodes.BadUnexpectedError, "VariableType does not support the IsAbstract attribute.");
}
variableTypeNode.IsAbstract = (bool)attributes[Attributes.IsAbstract].GetValue(typeof(bool));
// DataType Attribute
value = attributes[Attributes.DataType];
if (value == null)
{
throw ServiceResultException.Create(StatusCodes.BadUnexpectedError, "VariableType does not support the DataType attribute.");
}
variableTypeNode.DataType = (NodeId)attributes[Attributes.DataType].GetValue(typeof(NodeId));
// ValueRank Attribute
value = attributes[Attributes.ValueRank];
if (value == null)
{
throw ServiceResultException.Create(StatusCodes.BadUnexpectedError, "VariableType does not support the ValueRank attribute.");
}
variableTypeNode.ValueRank = (int)attributes[Attributes.ValueRank].GetValue(typeof(int));
// ArrayDimensions Attribute
value = attributes[Attributes.ArrayDimensions];
if (value != null && value.Value != null)
{
variableTypeNode.ArrayDimensions = (uint[])attributes[Attributes.ArrayDimensions].GetValue(typeof(uint[]));
}
node = variableTypeNode;
break;
}
case NodeClass.Method:
{
MethodNode methodNode = new MethodNode();
// Executable Attribute
value = attributes[Attributes.Executable];
if (value == null)
{
throw ServiceResultException.Create(StatusCodes.BadUnexpectedError, "Method does not support the Executable attribute.");
}
methodNode.Executable = (bool)attributes[Attributes.Executable].GetValue(typeof(bool));
// UserExecutable Attribute
value = attributes[Attributes.UserExecutable];
if (value == null)
{
throw ServiceResultException.Create(StatusCodes.BadUnexpectedError, "Method does not support the UserExecutable attribute.");
}
methodNode.UserExecutable = (bool)attributes[Attributes.UserExecutable].GetValue(typeof(bool));
node = methodNode;
break;
}
case NodeClass.DataType:
{
DataTypeNode dataTypeNode = new DataTypeNode();
// IsAbstract Attribute
value = attributes[Attributes.IsAbstract];
if (value == null)
{
throw ServiceResultException.Create(StatusCodes.BadUnexpectedError, "DataType does not support the IsAbstract attribute.");
}
dataTypeNode.IsAbstract = (bool)attributes[Attributes.IsAbstract].GetValue(typeof(bool));
node = dataTypeNode;
break;
}
case NodeClass.ReferenceType:
{
ReferenceTypeNode referenceTypeNode = new ReferenceTypeNode();
// IsAbstract Attribute
value = attributes[Attributes.IsAbstract];
if (value == null)
{
throw ServiceResultException.Create(StatusCodes.BadUnexpectedError, "ReferenceType does not support the IsAbstract attribute.");
}
referenceTypeNode.IsAbstract = (bool)attributes[Attributes.IsAbstract].GetValue(typeof(bool));
// Symmetric Attribute
value = attributes[Attributes.Symmetric];
if (value == null)
{
throw ServiceResultException.Create(StatusCodes.BadUnexpectedError, "ReferenceType does not support the Symmetric attribute.");
}
referenceTypeNode.Symmetric = (bool)attributes[Attributes.IsAbstract].GetValue(typeof(bool));
// InverseName Attribute
value = attributes[Attributes.InverseName];
if (value != null && value.Value != null)
{
referenceTypeNode.InverseName = (LocalizedText)attributes[Attributes.InverseName].GetValue(typeof(LocalizedText));
}
node = referenceTypeNode;
break;
}
case NodeClass.View:
{
ViewNode viewNode = new ViewNode();
// EventNotifier Attribute
value = attributes[Attributes.EventNotifier];
if (value == null)
{
throw ServiceResultException.Create(StatusCodes.BadUnexpectedError, "View does not support the EventNotifier attribute.");
}
viewNode.EventNotifier = (byte)attributes[Attributes.EventNotifier].GetValue(typeof(byte));
// ContainsNoLoops Attribute
value = attributes[Attributes.ContainsNoLoops];
if (value == null)
{
throw ServiceResultException.Create(StatusCodes.BadUnexpectedError, "View does not support the ContainsNoLoops attribute.");
}
viewNode.ContainsNoLoops = (bool)attributes[Attributes.ContainsNoLoops].GetValue(typeof(bool));
node = viewNode;
break;
}
}
// NodeId Attribute
value = attributes[Attributes.NodeId];
if (value == null)
{
throw ServiceResultException.Create(StatusCodes.BadUnexpectedError, "Node does not support the NodeId attribute.");
}
node.NodeId = (NodeId)attributes[Attributes.NodeId].GetValue(typeof(NodeId));
node.NodeClass = (NodeClass)nodeClass.Value;
// BrowseName Attribute
value = attributes[Attributes.BrowseName];
if (value == null)
{
throw ServiceResultException.Create(StatusCodes.BadUnexpectedError, "Node does not support the BrowseName attribute.");
}
node.BrowseName = (QualifiedName)attributes[Attributes.BrowseName].GetValue(typeof(QualifiedName));
// DisplayName Attribute
value = attributes[Attributes.DisplayName];
if (value == null)
{
throw ServiceResultException.Create(StatusCodes.BadUnexpectedError, "Node does not support the DisplayName attribute.");
}
node.DisplayName = (LocalizedText)attributes[Attributes.DisplayName].GetValue(typeof(LocalizedText));
// Description Attribute
value = attributes[Attributes.Description];
if (value != null && value.Value != null)
{
node.Description = (LocalizedText)attributes[Attributes.Description].GetValue(typeof(LocalizedText));
}
// WriteMask Attribute
value = attributes[Attributes.WriteMask];
if (value != null)
{
node.WriteMask = (uint)attributes[Attributes.WriteMask].GetValue(typeof(uint));
}
// UserWriteMask Attribute
value = attributes[Attributes.UserWriteMask];
if (value != null)
{
node.WriteMask = (uint)attributes[Attributes.UserWriteMask].GetValue(typeof(uint));
}
return node;
}
/// <summary>
/// Creates an VariableType node in the address space.
/// </summary>
public NodeId CreateVariableType(
NodeId parentId,
NodeId nodeId,
QualifiedName browseName,
VariableTypeAttributes attributes)
{
try
{
m_lock.Enter();
// check for null node id.
if (NodeId.IsNull(nodeId))
{
nodeId = CreateUniqueNodeId();
}
// check if node id exists.
if (m_nodes.Exists(nodeId))
{
throw ServiceResultException.Create(StatusCodes.BadNodeIdExists, "NodeId '{0}' already exists.", nodeId);
}
// find parent.
IVariableType parent = GetManagerHandle(parentId) as IVariableType;
if (parent == null)
{
throw ServiceResultException.Create(StatusCodes.BadParentNodeIdInvalid, "Parent node '{0}' does not exist or is not an VariableType.", parentId);
}
// validate reference.
ValidateReference(parent, ReferenceTypeIds.HasSubtype, false, NodeClass.VariableType);
// validate browse name.
if (QualifiedName.IsNull(browseName))
{
throw ServiceResultException.Create(StatusCodes.BadBrowseNameInvalid, "BrowsName must not be empty.");
}
// create node.
VariableTypeNode node = new VariableTypeNode();
node.NodeId = nodeId;
node.NodeClass = NodeClass.VariableType;
node.BrowseName = browseName;
UpdateAttributes(node, attributes);
// Value
if (attributes != null && (attributes.SpecifiedAttributes & (uint)NodeAttributesMask.Value) != 0)
{
node.Value = attributes.Value;
}
else
{
node.Value = Variant.Null;
}
// DataType
if (attributes != null && (attributes.SpecifiedAttributes & (uint)NodeAttributesMask.DataType) != 0)
{
node.DataType = attributes.DataType;
}
else
{
node.DataType = DataTypes.BaseDataType;
}
// ValueRank
if (attributes != null && (attributes.SpecifiedAttributes & (uint)NodeAttributesMask.ValueRank) != 0)
{
node.ValueRank = attributes.ValueRank;
}
else
{
node.ValueRank = ValueRanks.Scalar;
}
// ArrayDimensions
if (attributes != null && (attributes.SpecifiedAttributes & (uint)NodeAttributesMask.ArrayDimensions) != 0)
{
node.ArrayDimensions = attributes.ArrayDimensions;
}
else
{
node.ArrayDimensions = null;
}
// IsAbstract
if (attributes != null && (attributes.SpecifiedAttributes & (uint)NodeAttributesMask.IsAbstract) != 0)
{
node.IsAbstract = attributes.IsAbstract;
}
else
{
node.IsAbstract = false;
}
// add reference from parent.
AddReference(parent, ReferenceTypeIds.HasSubtype, false, node, true);
// add node.
AddNode(node);
// return the new node id.
return node.NodeId;
}
finally
{
m_lock.Exit();
}
}
public ArrayTypeNode(VariableTypeNode type)
{
this.type = type;
}
/// <summary>
/// Returns the value of an attribute.
/// </summary>
public void Read(
ReadValueId request,
DataValue result,
DiagnosticInfo diagnosticInfo)
{
lock (m_lock)
{
// find the node to read.
Node source = m_nodes.Find(request.NodeId);
result.ServerTimestamp = DateTime.UtcNow;
if (source == null)
{
result.StatusCode = new StatusCode(StatusCodes.BadNodeIdUnknown);
return;
}
result.Value = Variant.Null;
// switch on the attribute value.
switch (request.AttributeId)
{
case Attributes.NodeId:
{
result.Value = new Variant(source.NodeId);
break;
}
case Attributes.NodeClass:
{
result.Value = new Variant(DataTypes.EnumToMask(source.NodeClass));
break;
}
case Attributes.BrowseName:
{
result.Value = new Variant(source.BrowseName);
break;
}
case Attributes.DisplayName:
{
result.Value = new Variant(source.DisplayName);
break;
}
case Attributes.Description:
{
result.Value = new Variant(source.Description);
break;
}
case Attributes.WriteMask:
{
result.Value = new Variant(source.WriteMask);
break;
}
case Attributes.UserWriteMask:
{
result.Value = new Variant(source.UserWriteMask);
break;
}
case Attributes.Value:
{
// check if another component has installed a read callback.
ReadValueEventHandler callback = null;
if (m_callbacks.TryGetValue(source.NodeId.Identifier, out callback))
{
result.Value = new Variant(callback());
break;
}
// use the value cached in the node otherwise.
VariableNode variable = source as VariableNode;
if (variable != null)
{
result.Value = variable.Value;
result.SourceTimestamp = DateTime.UtcNow; // The Value attribute requires a SourceTimestamp.
break;
}
VariableTypeNode variableType = source as VariableTypeNode;
if (variableType != null)
{
result.Value = variableType.Value;
result.SourceTimestamp = DateTime.UtcNow; // The Value attribute requires a SourceTimestamp.
break;
}
result.StatusCode = new StatusCode(StatusCodes.BadAttributeIdInvalid);
break;
}
case Attributes.DataType:
{
VariableNode variable = source as VariableNode;
if (variable != null)
{
result.Value = new Variant(variable.DataType);
break;
}
VariableTypeNode variableType = source as VariableTypeNode;
if (variableType != null)
{
result.Value = new Variant(variableType.DataType);
break;
}
result.StatusCode = new StatusCode(StatusCodes.BadAttributeIdInvalid);
break;
}
case Attributes.ValueRank:
{
VariableNode variable = source as VariableNode;
if (variable != null)
{
result.Value = new Variant(variable.ValueRank);
break;
}
VariableTypeNode variableType = source as VariableTypeNode;
if (variableType != null)
{
result.Value = new Variant(variableType.ValueRank);
break;
}
result.StatusCode = new StatusCode(StatusCodes.BadAttributeIdInvalid);
break;
}
case Attributes.MinimumSamplingInterval:
{
VariableNode variable = source as VariableNode;
if (variable != null)
{
result.Value = new Variant(variable.MinimumSamplingInterval);
break;
}
result.StatusCode = new StatusCode(StatusCodes.BadAttributeIdInvalid);
break;
}
case Attributes.Historizing:
{
VariableNode variable = source as VariableNode;
if (variable != null)
{
result.Value = new Variant(variable.Historizing);
break;
}
result.StatusCode = new StatusCode(StatusCodes.BadAttributeIdInvalid);
break;
}
case Attributes.AccessLevel:
{
VariableNode variable = source as VariableNode;
if (variable != null)
{
result.Value = new Variant(variable.AccessLevel);
break;
}
result.StatusCode = new StatusCode(StatusCodes.BadAttributeIdInvalid);
break;
}
case Attributes.UserAccessLevel:
{
VariableNode variable = source as VariableNode;
if (variable != null)
{
result.Value = new Variant(variable.UserAccessLevel);
break;
}
result.StatusCode = new StatusCode(StatusCodes.BadAttributeIdInvalid);
break;
}
case Attributes.EventNotifier:
{
ObjectNode objectn = source as ObjectNode;
if (objectn != null)
{
result.Value = new Variant(objectn.EventNotifier);
break;
}
ViewNode view = source as ViewNode;
if (view != null)
{
result.Value = new Variant(view.EventNotifier);
break;
}
result.StatusCode = new StatusCode(StatusCodes.BadAttributeIdInvalid);
break;
}
case Attributes.Executable:
{
MethodNode method = source as MethodNode;
if (method != null)
{
result.Value = new Variant(method.Executable);
break;
}
result.StatusCode = new StatusCode(StatusCodes.BadAttributeIdInvalid);
break;
}
case Attributes.UserExecutable:
{
MethodNode method = source as MethodNode;
if (method != null)
{
result.Value = new Variant(method.UserExecutable);
break;
}
result.StatusCode = new StatusCode(StatusCodes.BadAttributeIdInvalid);
break;
}
case Attributes.ContainsNoLoops:
{
ViewNode view = source as ViewNode;
if (view != null)
{
result.Value = new Variant(view.ContainsNoLoops);
break;
}
result.StatusCode = new StatusCode(StatusCodes.BadAttributeIdInvalid);
break;
}
case Attributes.InverseName:
{
ReferenceTypeNode referenceType = source as ReferenceTypeNode;
if (referenceType != null)
{
result.Value = new Variant(referenceType.InverseName);
break;
}
result.StatusCode = new StatusCode(StatusCodes.BadAttributeIdInvalid);
break;
}
case Attributes.IsAbstract:
{
DataTypeNode dataType = source as DataTypeNode;
if (dataType != null)
{
result.Value = new Variant(dataType.IsAbstract);
break;
}
ReferenceTypeNode referenceType = source as ReferenceTypeNode;
if (referenceType != null)
{
result.Value = new Variant(referenceType.IsAbstract);
break;
}
ObjectTypeNode objectType = source as ObjectTypeNode;
if (objectType != null)
{
result.Value = new Variant(objectType.IsAbstract);
break;
}
VariableTypeNode variableType = source as VariableTypeNode;
if (variableType != null)
{
result.Value = new Variant(variableType.IsAbstract);
break;
}
result.StatusCode = new StatusCode(StatusCodes.BadAttributeIdInvalid);
break;
}
case Attributes.Symmetric:
{
ReferenceTypeNode referenceType = source as ReferenceTypeNode;
if (referenceType != null)
{
result.Value = new Variant(referenceType.Symmetric);
break;
}
result.StatusCode = new StatusCode(StatusCodes.BadAttributeIdInvalid);
break;
}
default:
{
result.StatusCode = new StatusCode(StatusCodes.BadAttributeIdInvalid);
break;
}
}
}
}
public ArrayCreationNode(VariableTypeNode variableTypeNode, ITreeNode size)
{
this.primitiveTypeNode = variableTypeNode;
this.size = size;
}