internal void UpdateOriginNamespaceOnRoot(int hashcode, EndValueNamespaceNavigationNode value)
{
if (value != null && !_originNamespaceOnRoot.ContainsKey(hashcode))
{
lock (_originNamespaceUpdateLock) {
if (!_originNamespaceOnRoot.ContainsKey(hashcode))
{
_originNamespaceOnRoot.Add(hashcode, value);
}
}
}
}
public static bool Match(string @namespace, NamespaceNavigator nav, out EndValueNamespaceNavigationNode value)
{
value = default(EndValueNamespaceNavigationNode);
if (string.IsNullOrWhiteSpace(@namespace))
{
return(false);
}
if (string.Compare(@namespace, "Default", StringComparison.OrdinalIgnoreCase) == 0)
{
return(false);
}
if (nav == null)
{
return(false);
}
//if (nav.IsRoot() && nav.OriginNamespaceOnRoot.Contains(@namespace)) return true;
var currentNav = nav.IsRoot() ? nav : GetRoot(nav);
if (currentNav == null)
{
return(false);
}
var nss = @namespace.Split('.');
var index = 0;
do
{
if (string.CompareOrdinal(currentNav.NamespaceFragment, "*") == 0)
{
value = currentNav.GetValue();
return(true);
}
if (string.CompareOrdinal(nss[index], currentNav.NamespaceFragment) != 0)
{
return(false);
}
if (index + 1 < nss.Length && !currentNav.HasNextNav())
{
value = currentNav.GetValue();
return(true);
}
currentNav = currentNav.GetNextNav(nss[++index]);
} while (index < nss.Length);
return(false);
}
/// <inheritdoc />
public NamespaceNavigator Parse(string @namespace, string level, out EndValueNamespaceNavigationNode endValueNode)
{
if (string.IsNullOrWhiteSpace(@namespace))
{
throw new ArgumentNullException(nameof(@namespace));
}
endValueNode = new EndValueNamespaceNavigationNode(level);
if (@namespace == "*")
{
return new NamespaceNavigator("*")
{
Value = endValueNode
}
}
;
if (@namespace == "Default")
{
return(NamespaceNavigator.Empty);
}
if (@namespace.IndexOf(".", StringComparison.Ordinal) < 0)
{
return new NamespaceNavigator(@namespace)
{
Value = endValueNode
}
}
;
var nss = @namespace.Split('.');
var root = new NamespaceNavigator(nss[0]);
var currentNav = root;
for (var i = 1; i < nss.Length; i++)
{
var _ = new NamespaceNavigator(nss[i]);
currentNav.AddChild(_);
currentNav = _;
if (nss[i] == "*")
{
break;
}
}
currentNav.Value = endValueNode;
return(root);
}
}
}
/// <inheritdoc />
public bool Match(string @namespace, out EndValueNamespaceNavigationNode value)
{
value = default;
if (string.IsNullOrWhiteSpace(@namespace))
{
return(false);
}
if (_namespaceCache.ContainsKey(@namespace.GetHashCode()))
{
return(true);
}
var nss = @namespace.Split('.');
return(_namespaceNavCache.TryGetValue(nss[0].GetHashCode(), out var nav) && NamespaceNavigationMatcher.Match(@namespace, nav, out value));
}
/// <inheritdoc />
public NamespaceNavigator Parse(string @namespace, string level, out EndValueNamespaceNavigationNode endValueNode)
{
endValueNode = EndValueNamespaceNavigationNode.Null;
if (string.IsNullOrWhiteSpace(@namespace))
{
return(NamespaceNavigator.Empty);
}
if (@namespace == "Default")
{
return(NamespaceNavigator.Empty);
}
if (_namespaceCache.ContainsKey(@namespace.GetHashCode()))
{
return(_namespaceCache[@namespace.GetHashCode()]);
}
var nss = @namespace.Split('.');
if (_namespaceNavCache.TryGetValue(nss[0].GetHashCode(), out var nav))
{
var currentNav = nav;
for (var i = 1; i < nss.Length; i++)
{
if (nss[i] == "*")
{
lock (_namespacePoolLock) {
currentNav.AddChild(_namespaceNavigationParser.Parse("*", level, out endValueNode));
_namespaceCache.Add(@namespace.GetHashCode(), nav);
nav.UpdateOriginalNamespaceOnRoot(@namespace.GetHashCode(), endValueNode);
}
return(nav);
}
var tempNav = currentNav.GetNextNav(nss[i]);
if (tempNav == null || tempNav is EmptyNamespaceNavigationNode)
{
var nss2 = new string[nss.Length - i];
Array.Copy(nss, i, nss2, 0, nss.Length - i);
lock (_namespacePoolLock) {
currentNav.AddChild(_namespaceNavigationParser.Parse(string.Join(".", nss2), level, out endValueNode));
_namespaceCache.Add(@namespace.GetHashCode(), nav);
nav.UpdateOriginalNamespaceOnRoot(@namespace.GetHashCode(), endValueNode);
}
return(nav);
}
currentNav = tempNav;
}
endValueNode = currentNav.GetValue();
nav.UpdateOriginalNamespaceOnRoot(@namespace.GetHashCode(), endValueNode);
return(nav);
}
lock (_namespacePoolLock) {
var newNav = _namespaceNavigationParser.Parse(@namespace, level, out endValueNode);
_namespaceCache.Add(@namespace.GetHashCode(), newNav);
_namespaceNavCache.Add(nss[0].GetHashCode(), newNav);
newNav.UpdateOriginalNamespaceOnRoot(@namespace.GetHashCode(), endValueNode);
return(newNav);
}
}
public virtual void SetValue(EndValueNamespaceNavigationNode nav) => Value = nav;
public override void SetValue(EndValueNamespaceNavigationNode nav)
{
}