/// <inheritdoc/>
public Schema.DataType TryResolve(Schema.ImportDirective import,
XmlQualifiedName typeName)
{
if (import == null)
{
throw new ArgumentNullException(nameof(import));
}
if (typeName.IsNullOrEmpty())
{
throw new ArgumentNullException(nameof(typeName));
}
if (!_cache.TryGetValue(import, out var types))
{
import = import.Copy();
types = Load(import);
if (types == null)
{
// Try any version
import.TargetVersion = null;
types = Load(import);
if (types == null)
{
return(null);
}
}
_cache.Add(import, types);
}
return(types.TryResolve(import, typeName));
}
/// <inheritdoc/>
public DataType TryResolve(ImportDirective import, XmlQualifiedName typeName)
{
if (import == null)
{
throw new ArgumentNullException(nameof(import));
}
if (typeName.IsNullOrEmpty())
{
throw new ArgumentNullException(nameof(typeName));
}
foreach (var resolver in _resolvers)
{
try {
var type = resolver.TryResolve(import, typeName);
if (type != null)
{
return(type);
}
}
catch {
continue;
}
}
return(null);
}
/// <inheritdoc/>
public NodeDesign TryResolve(Namespace ns, XmlQualifiedName symbolicId)
{
if (ns == null)
{
throw new ArgumentNullException(nameof(ns));
}
if (symbolicId.IsNullOrEmpty())
{
throw new ArgumentNullException(nameof(symbolicId));
}
if (!_resolvers.TryGetValue(ns, out var resolver))
{
resolver = LoadDesign(ns) as INodeResolver;
if (resolver == null)
{
return(null);
}
_resolvers.Add(ns, resolver);
if (!_assigners.ContainsKey(ns))
{
if (LoadIdentifiers(ns) is INodeIdAssigner assigner)
{
_assigners.Add(ns, assigner);
}
}
}
return(resolver.TryResolve(ns, symbolicId));
}
/// <inheritdoc/>
public NodeDesign TryResolve(Namespace ns, XmlQualifiedName symbolicId)
{
if (ns == null)
{
throw new ArgumentNullException(nameof(ns));
}
if (symbolicId.IsNullOrEmpty())
{
throw new ArgumentNullException(nameof(symbolicId));
}
foreach (var resolver in _resolvers)
{
try {
// Try to delegate to one of the resolvers
var node = resolver.TryResolve(ns, symbolicId);
if (node != null)
{
return(node);
}
}
catch {
continue;
}
}
return(null);
}
/// <summary>
/// Get symbolic id for a node that is either root or has the specified parent.
/// </summary>
/// <param name="parent"></param>
/// <param name="symbolicName"></param>
/// <returns></returns>
public static XmlQualifiedName CreateSymbolicId(this NodeDesign parent,
XmlQualifiedName symbolicName)
{
if (symbolicName.IsNullOrEmpty())
{
throw new ArgumentNullException(nameof(symbolicName));
}
return(new XmlQualifiedName(CreateSymbolicId(parent?.SymbolicId?.Name, symbolicName.Name),
symbolicName.Namespace));
}
/// <summary>
/// Adds a reference to the AddressSpace.
/// </summary>
/// <param name="sourceIndex">Index of the source node that must be registered before this method is called.</param>
/// <param name="referenceTypeName">Name of the reference type.</param>
/// <param name="inverse">if set to <c>true</c> it is inverse reference.</param>
/// <param name="targetName">Name of the target element this reference points to.</param>
public void AddReference(int sourceIndex, XmlQualifiedName referenceTypeName, bool inverse, XmlQualifiedName targetName)
{
//targetName can be null in case of HasTypeDefinition of basic types.
this.Assert((referenceTypeName != null && !referenceTypeName.IsEmpty), sourceIndex, "The reference type name of the reference cannot be null or empty");
if (targetName.IsNullOrEmpty() || referenceTypeName.IsNullOrEmpty())
{
return;
}
int targetIndex = TryGetAndAddIfNeeded(targetName.ToString());
this.AddReference(sourceIndex, referenceTypeName, inverse, targetIndex);
}
/// <summary>
/// Convert type declartion type to design type
/// </summary>
/// <param name="baseType"></param>
/// <returns></returns>
private static XmlQualifiedName ToDesignBaseDataType(this XmlQualifiedName baseType)
{
if (baseType.IsNullOrEmpty())
{
return(null);
}
switch (baseType.Name)
{
case "ExtensionObject":
return(Constants.Structure);
case "Variant":
return(Constants.BaseDataType);
}
return(new XmlQualifiedName(baseType.Name, Namespaces.OpcUa));
}
/// <inheritdoc/>
public DataType TryResolve(ImportDirective import, XmlQualifiedName typeName)
{
if (import == null)
{
throw new ArgumentNullException(nameof(import));
}
if (typeName.IsNullOrEmpty())
{
throw new ArgumentNullException(nameof(typeName));
}
// We only resolve if we own the namespace.
if (import.Namespace == _dictionary.TargetNamespace &&
(import.TargetVersion == null ||
import.TargetVersion == _dictionary.TargetVersion))
{
return(ResolveType(typeName));
}
return(null);
}
/// <summary>
/// Validates the base type of a complex type.
/// </summary>
/// <param name="complexType"></param>
/// <param name="baseType"></param>
/// <param name="fields"></param>
private void ValidateBaseType(ComplexType complexType,
XmlQualifiedName baseType, Dictionary <string, FieldType> fields)
{
if (baseType.IsNullOrEmpty())
{
return;
}
var parentType = ResolveType(baseType);
if (!(parentType is ComplexType complexParent))
{
throw new FormatException($"The base type '{baseType}' for complex type " +
$"'{complexType.Name}' is not a complex type.");
}
ValidateBaseType(complexType, complexParent.BaseType, fields);
foreach (var field in complexParent.Field)
{
fields.Add(field.Name, field);
}
}
/// <inheritdoc/>
public object TryAssignId(Namespace ns, XmlQualifiedName symbolicId)
{
if (ns == null)
{
throw new ArgumentNullException(nameof(ns));
}
if (symbolicId.IsNullOrEmpty())
{
throw new ArgumentNullException(nameof(symbolicId));
}
if (!_assigners.TryGetValue(ns, out var assigner))
{
assigner = LoadIdentifiers(ns) as INodeIdAssigner;
if (assigner == null)
{
return(null);
}
}
return(assigner.TryAssignId(ns, symbolicId));
}
/// <summary>
/// Resolve type
/// </summary>
/// <param name="typeName"></param>
/// <returns></returns>
public DataType ResolveType(XmlQualifiedName typeName)
{
if (typeName.IsNullOrEmpty())
{
return(null);
}
if (!_datatypes.TryGetValue(typeName, out var dataType))
{
if (typeName.Namespace != _dictionary.TargetNamespace)
{
// Try and resolve through the import directives
dataType = ResolveFromImports(typeName, dataType);
}
}
// If type declartion, resolve the source type
if (dataType is TypeDeclaration declaration)
{
return(ResolveType(declaration.SourceType));
}
return(dataType);
}
/// <summary>
/// Checks whether the qname is valid
/// </summary>
/// <param name="qname"></param>
/// <returns></returns>
public static bool IsValid(this XmlQualifiedName qname)
{
return(!qname.IsNullOrEmpty() && !string.IsNullOrEmpty(qname.Namespace) &&
IsValidName(qname.Name));
}