public void AddressSpaceContextCreatorTestMethod()
{
AddressSpaceContext _as = new AddressSpaceContext(x => { });
Assert.IsNotNull(_as);
UANodeContext _context = null;
_as.UTTryGetUANodeContext(VariableTypes.PropertyType, x => _context = x);
Assert.IsNotNull(_context);
}
private void ImportUANode(UANode node, UAModelContext modelContext, Action<TraceMessage> traceEvent)
{
try
{
if (node == null)
m_TraceEvent(TraceMessage.BuildErrorTraceMessage(BuildError.NodeCannotBeNull, "At Importing UANode."));
NodeId nodeId = modelContext.ImportNodeId(node.NodeId, false, m_TraceEvent);
UANodeContext _newNode = null;
string nodeIdKey = nodeId.ToString();
if (!m_NodesDictionary.TryGetValue(nodeIdKey, out _newNode))
{
_newNode = new UANodeContext(this, modelContext, nodeId);
_newNode.Update(node, traceEvent);
m_NodesDictionary.Add(nodeIdKey, _newNode);
}
else
{
if (_newNode.UANode != null)
m_TraceEvent(TraceMessage.BuildErrorTraceMessage(BuildError.NodeIdDuplicated, String.Format("The {0} is already defined.", node.NodeId.ToString())));
_newNode.Update(node, traceEvent);
}
foreach (Reference _rf in node.References)
{
UAReferenceContext _rs = UAReferenceContext.NewReferenceStub(_rf, this, modelContext, _newNode, m_TraceEvent);
if (!m_References.ContainsKey(_rs.Key))
m_References.Add(_rs.Key, _rs);
}
}
catch (Exception _ex)
{
string _msg = String.Format("ImportUANode {1} is interrupted by exception {0}", _ex.Message, node.NodeId);
m_TraceEvent(TraceMessage.DiagnosticTraceMessage(_msg));
}
}
private void GetChildren(UANodeContext type, List<UANodeContext> instances)
{
IEnumerable<UANodeContext> _children = m_References.Values.Where<UAReferenceContext>(x => x.SourceNode == type).
Where<UAReferenceContext>(x => (x.ReferenceKind == ReferenceKindEnum.HasProperty || x.ReferenceKind == ReferenceKindEnum.HasComponent)).
Select<UAReferenceContext, UANodeContext>(x => x.TargetNode);
instances.AddRange(_children);
}
private void GetBaseTypes(UANodeContext rootNode, List<UANodeContext> inheritanceChain)
{
if (rootNode == null)
throw new ArgumentNullException("rootNode");
if (rootNode.InRecursionChain)
throw new ArgumentOutOfRangeException("Circular reference");
rootNode.InRecursionChain = true;
IEnumerable<UANodeContext> _derived = m_References.Values.Where<UAReferenceContext>(x => (x.TypeNode.NodeIdContext == ReferenceTypeIds.HasSubtype) && (x.TargetNode == rootNode)).
Select<UAReferenceContext, UANodeContext>(x => x.SourceNode);
inheritanceChain.AddRange(_derived);
if (_derived.Count<UANodeContext>() > 1)
throw new ArgumentOutOfRangeException("To many subtypes");
else if (_derived.Count<UANodeContext>() == 1)
GetBaseTypes(_derived.First<UANodeContext>(), inheritanceChain);
rootNode.InRecursionChain = false;
}
internal IEnumerable<UAReferenceContext> GetReferences2Me(UANodeContext index)
{
return m_References.Values.Where<UAReferenceContext>(x => x.TargetNode == index && x.ParentNode != index);
}
internal UANodeContext GetOrCreateNodeContext(NodeId nodeId, UAModelContext modelContext, Action<TraceMessage> traceEvent)
{
UANodeContext _ret;
string _idKey = nodeId.ToString();
if (!m_NodesDictionary.TryGetValue(_idKey, out _ret))
{
_ret = new UANodeContext(this, modelContext, nodeId);
m_NodesDictionary.Add(_idKey, _ret);
}
return _ret;
}
internal IEnumerable<UAReferenceContext> GetMyReferences(UANodeContext index)
{
return m_References.Values.Where<UAReferenceContext>(x => (x.ParentNode == index));
}
internal void GetDerivedInstances(UANodeContext rootNode, List<UANodeContext> list)
{
List<UANodeContext> _col = new List<UANodeContext>();
_col.Add(rootNode);
GetBaseTypes(rootNode, _col);
foreach (UANodeContext _type in _col)
GetChildren(_type, list);
}
//methods
private ReferenceKindEnum GetReferenceKind(UANodeContext TypeNode)
{
if (TypeNode.NodeIdContext.NamespaceIndex != 0)
return ReferenceKindEnum.Custom;
ReferenceKindEnum _ret = default(ReferenceKindEnum);
switch (TypeNode.NodeIdContext.UintIdentifier())
{
case ReferenceTypes.HierarchicalReferences:
_ret = ReferenceKindEnum.HierarchicalReferences;
break;
case ReferenceTypes.HasComponent:
_ret = ReferenceKindEnum.HasComponent;
break;
case ReferenceTypes.HasProperty:
_ret = ReferenceKindEnum.HasProperty;
break;
case ReferenceTypes.HasModellingRule:
_ret = ReferenceKindEnum.HasModellingRule;
break;
case ReferenceTypes.HasTypeDefinition:
_ret = ReferenceKindEnum.HasTypeDefinition;
break;
case ReferenceTypes.HasSubtype:
_ret = ReferenceKindEnum.HasSubtype;
break;
default:
_ret = ReferenceKindEnum.Custom;
break;
}
return _ret;
}
internal static UAReferenceContext NewReferenceStub(Reference reference, AddressSpaceContext addressSpaceContext, UAModelContext modelContext, UANodeContext parentNode, Action<TraceMessage> traceEvent)
{
UANodeContext targetNode = modelContext.GetOrCreateNodeContext(reference.Value, true, traceEvent);
UAReferenceContext _stb = new UAReferenceContext()
{
m_Context = addressSpaceContext,
ParentNode = parentNode,
SourceNode = reference.IsForward ? parentNode : targetNode,
ModelNode = reference,
TargetNode = reference.IsForward ? targetNode : parentNode,
TypeNode = modelContext.GetOrCreateNodeContext(reference.ReferenceType, true, traceEvent),
};
if (_stb.TypeNode != null && _stb.TypeNode.NodeIdContext.NamespaceIndex == 0)
_stb.ReferenceKind = _stb.GetReferenceKind(_stb.TypeNode);
return _stb;
}
