public override INode Resolve(string uri, NodeType nodeType, AddressScope scope, FileSystemOptions options)
{
bool success;
IFileSystem fileSystem;
var address = LayeredNodeAddress.Parse(uri);
lock (this.fileSystemCache)
{
success = this.fileSystemCache.TryGetValue(address.RootUri, out fileSystem);
}
if (!success)
{
var networkUri = String.Format("netvfs://{0}[" + uri + "]/", this.ipAddress);
fileSystem = FileSystemManager.GetManager().ResolveDirectory(networkUri).FileSystem;
lock (this.fileSystemCache)
{
this.fileSystemCache.Add(address.RootUri, fileSystem);
}
}
return fileSystem.Resolve(address.PathAndQuery);
}
public override INode Resolve(string uri, NodeType nodeType, AddressScope scope, FileSystemOptions options)
{
if (uri.IsNullOrEmpty())
{
if (uri == null)
{
throw new ArgumentNullException(nameof(uri));
}
else
{
throw new ArgumentException(nameof(uri));
}
}
if (uri[0] == ' ')
{
uri = uri.Trim();
}
if (uri.Length == 0)
{
throw new ArgumentException(uri, nameof(uri));
}
foreach (var provider in this.providers.Where(provider => provider.SupportsUri(uri)))
{
return(provider.Find(this, uri, nodeType, options));
}
throw new NotSupportedException(uri);
}
public virtual INodeAddress ResolveAddress(string name, AddressScope scope)
{
int x;
var query = "";
if (name.Length == 0 || (name.Length > 0 && name[0] != FileSystemManager.RootChar))
{
// Path is relative.
if (this.IsRoot)
{
name = FileSystemManager.RootChar + name;
}
else
{
name = this.absolutePath + FileSystemManager.SeperatorChar + name;
}
}
if ((x = name.IndexOf('?')) >= 0)
{
query = name.Substring(x + 1);
name = name.Substring(0, x);
}
name = StringUriUtils.NormalizePath(name);
if (!CheckPathScope(this.AbsolutePath, name, scope))
{
throw new AddressScopeValidationException(name, scope);
}
return(CreateAddress(name, query));
}
public override INode Resolve(string uri, NodeType nodeType, AddressScope scope, FileSystemOptions options)
{
bool success;
IFileSystem fileSystem;
var address = LayeredNodeAddress.Parse(uri);
lock (this.fileSystemCache)
{
success = this.fileSystemCache.TryGetValue(address.RootUri, out fileSystem);
}
if (!success)
{
var networkUri = String.Format("netvfs://{0}[" + uri + "]/", this.ipAddress);
fileSystem = FileSystemManager.GetManager().ResolveDirectory(networkUri).FileSystem;
lock (this.fileSystemCache)
{
this.fileSystemCache.Add(address.RootUri, fileSystem);
}
}
return(fileSystem.Resolve(address.PathAndQuery));
}
public override INode Resolve(string name, NodeType nodeType, AddressScope scope)
{
var nodeAddress = base.ResolveAddress(name, scope);
if (nodeAddress.IsDescendentOf(this.Address, AddressScope.Descendent))
{
INode jumpPointNode;
if (jumpPoints.TryGetValue(name, out jumpPointNode))
{
var relativePath = this.Address.GetRelativePathTo(nodeAddress);
if (relativePath == name)
{
return(jumpPointNode);
}
else if (jumpPointNode.NodeType == NodeType.Directory)
{
return(jumpPointNode.Resolve(relativePath));
}
}
}
return(base.Resolve(nodeAddress, nodeType, scope));
}
/// <summary>
/// Initializes a new instance of the <see cref="Address"/> struct.
/// </summary>
/// <param name="scope">The scope.</param>
/// <param name="block">The block.</param>
/// <param name="page">The page.</param>
/// <param name="document">The document.</param>
public Address(AddressScope scope, ushort block, ushort page, ushort document)
{
var a = (ulong)block << 32 | (uint)page << 16 | document;
a |= ((ulong)scope << 48);
FullAddress = a;
}
private int GetHeaderLengthForScope(AddressScope scope)
{
return(scope switch
{
AddressScope.Block => Constants.BLOCK_HEADER_SIZE,
AddressScope.Page => Constants.PAGE_HEADER_SIZE,
AddressScope.Document => Constants.DOCUMENT_HEADER_SIZE,
_ => throw new ArgumentOutOfRangeException(nameof(scope))
});
public Address(AddressScope scope, ulong fullAddress)
{
if (((AddressScope)(fullAddress >> 48)) != scope)
{
fullAddress ^= (ulong)((fullAddress >> 48)) << 48;
fullAddress ^= (ulong)scope << 48;
}
FullAddress = fullAddress;
}
protected virtual INodeAddress ResolveAddress(string name, AddressScope scope)
{
if (this.NodeType.IsLikeDirectory)
{
return(this.Address.ResolveAddress(name, scope));
}
else
{
return(this.Address.Parent.ResolveAddress(name, scope));
}
}
public override INode Resolve(string name, NodeType nodeType, AddressScope scope)
{
if (!nodeType.IsLikeDirectory && name.EndsWith(FileSystemManager.SeperatorString))
{
name = name.TrimRight(FileSystemManager.SeperatorChar);
}
var nodeAddress = this.rootAddress.ResolveAddress(name);
if (nodeType == NodeType.Any && name.EndsWith(FileSystemManager.SeperatorString))
{
nodeType = NodeType.Directory;
}
return(Resolve(nodeAddress, nodeType));
}
public override INode Resolve(string name, NodeType nodeType, AddressScope scope)
{
if (this.parentAddress == null)
{
if (this.node.NodeType == NodeType.File)
{
this.parentAddress = this.node.Address.Parent;
}
else
{
this.parentAddress = this.node.Address;
}
}
return this.node.FileSystem.Resolve(this.parentAddress.ResolveAddress(name).AbsolutePath, nodeType, scope);
}
public override INode Resolve(string name, NodeType nodeType, AddressScope scope)
{
if (this.parentAddress == null)
{
if (this.node.NodeType == NodeType.File)
{
this.parentAddress = this.node.Address.Parent;
}
else
{
this.parentAddress = this.node.Address;
}
}
return(this.node.FileSystem.Resolve(this.parentAddress.ResolveAddress(name).AbsolutePath, nodeType, scope));
}
/// <summary>
/// Resolves a file using the current object's <see cref="NodeResolver"/>.
/// </summary>
/// <remarks>
/// The default implementation delegates to
/// <see cref="Resolve(string, NodeType, AddressScope)"/>.
/// </remarks>
public override IDirectory ResolveDirectory(string name, AddressScope scope)
{
return(this.NodeResolver.ResolveDirectory(name, scope));
}
public void ShouldNotCreateAddressWhenInvalidCountry()
{
var address = new Address(3060, "Rua Mentor Couto", "Engenho Pequeno", "São Gonçalo", "RJ", "");
Assert.AreEqual(false, AddressScope.AddressValid(address));
}
public void ShouldNotCreateAddressWhenInvalidStreet()
{
var address = new Address(3060, "", "Engenho Pequeno", "São Gonçalo", "RJ", "BR");
Assert.AreEqual(false, AddressScope.AddressValid(address));
}
public override INode Resolve(string name, NodeType nodeType, AddressScope scope)
{
return this.viewFileSystem.Resolve(this.parentAddress.ResolveAddress(name).AbsolutePath, nodeType, scope);
}
public virtual INode Resolve(string name, NodeType nodeType, AddressScope scope)
{
return(this.Wrappee.Resolve(name, nodeType, scope));
}
public virtual INode Resolve(string name, AddressScope scope)
{
return Resolve(name, NodeType.Any, scope);
}
public Address(AddressScope scope, ushort block) : this(scope, block, 0)
{
}
public AddressScopeValidationException(string path, AddressScope scope, Exception innerException)
: base(String.Format("The path \"{0}\" is not valid within the scope \"{1}\"", path, scope), innerException)
{
}
public AddressScopeValidationException(string path, AddressScope scope)
: this(path, scope, null)
{
}
public AddressScopeValidationException(string path, AddressScope scope, Exception innerException)
: base(String.Format("The path \"{0}\" is not valid within the scope \"{1}\"", path, scope), innerException)
{
}
public AddressScopeValidationException(string path, AddressScope scope)
: this(path, scope, null)
{
}
public abstract INode Resolve(string uri, NodeType nodeType, AddressScope scope, FileSystemOptions options);
public override INode Resolve(string uri, NodeType nodeType, AddressScope scope)
{
return(Resolve(uri, nodeType, scope, FileSystemOptions.Default));
}
public virtual IDirectory ResolveDirectory(string name, AddressScope scope)
{
return((IDirectory)Resolve(name, NodeType.Directory, scope));
}
public abstract INode Resolve(string uri, NodeType nodeType, AddressScope scope, FileSystemOptions options = null);
public virtual IFile ResolveFile(string name, AddressScope scope)
{
return((IFile)Resolve(name, NodeType.File, scope));
}
public virtual IDirectory ResolveDirectory(string name, AddressScope scope)
{
return (IDirectory)Resolve(name, NodeType.Directory, scope);
}
public virtual INode Resolve(string name, AddressScope scope)
{
return(Resolve(name, NodeType.Any, scope));
}
public virtual bool IsDescendentOf(INodeAddress name, StringComparison comparisonType, AddressScope scope)
{
return this.Wrappee.IsDescendentOf(name, comparisonType, scope);
}
public abstract INode Resolve(string name, NodeType nodeType, AddressScope scope);
public override INode Resolve(string uri, NodeType nodeType, AddressScope scope, FileSystemOptions options)
{
if (uri.IsNullOrEmpty())
{
if (uri == null)
{
throw new ArgumentNullException("uri");
}
else
{
throw new ArgumentException("uri");
}
}
if (uri[0] == ' ')
{
uri = uri.Trim();
}
if (uri.Length == 0)
{
throw new ArgumentException(uri, "uri");
}
foreach (var provider in providers)
{
if (provider.SupportsUri(uri))
{
return provider.Find(this, uri, nodeType, options);
}
}
throw new NotSupportedException(uri);
}
/// <summary>
/// Resolves a file using the current object's <see cref="NodeResolver"/>.
/// </summary>
/// <remarks>
/// The default implementation delegates to
/// <see cref="Resolve(string, NodeType, AddressScope)"/>.
/// </remarks>
public override IFile ResolveFile(string name, AddressScope scope)
{
return this.NodeResolver.ResolveFile(name, scope);
}
public void ShouldCreateAddress()
{
var address = new Address(3060, "Rua Mentor Couto", "Engenho Pequeno", "São Gonçalo", "RJ", "BR");
Assert.AreEqual(true, AddressScope.AddressValid(address));
}
/// <summary>
/// Resolves a file using the current object's <see cref="NodeResolver"/>.
/// </summary>
/// <remarks>
/// The default implementation delegates to
/// <see cref="Resolve(string, NodeType, AddressScope)"/>.
/// </remarks>
public override IDirectory ResolveDirectory(string name, AddressScope scope)
{
return this.NodeResolver.ResolveDirectory(name, scope);
}
public void ShouldNotCreateAddressWhenInvalidNeighborhood()
{
var address = new Address(3060, "Rua Mentor Couto", "", "São Gonçalo", "RJ", "BR");
Assert.AreEqual(false, AddressScope.AddressValid(address));
}
/// <summary>
/// Resolves a file using the current object's <see cref="NodeResolver"/>.
/// </summary>
/// <remarks>
/// The default implementation delegates to
/// <see cref="Resolve(string, NodeType, AddressScope)"/>.
/// </remarks>
public override INode Resolve(string name, NodeType nodeType, AddressScope scope)
{
return this.NodeResolver.Resolve(name, nodeType, scope);
}
/// <summary>
/// Resolves a file using the current object's <see cref="NodeResolver"/>.
/// </summary>
/// <remarks>
/// The default implementation delegates to
/// <see cref="Resolve(string, NodeType, AddressScope)"/>.
/// </remarks>
public override IFile ResolveFile(string name, AddressScope scope)
{
return(this.NodeResolver.ResolveFile(name, scope));
}
public override INode Resolve(string name, NodeType nodeType, AddressScope scope)
{
var address = this.Address.ResolveAddress(name, scope);
return(this.FileSystem.Resolve(address, nodeType));
}
/// <summary>
/// Resolves a file using the current object's <see cref="NodeResolver"/>.
/// </summary>
/// <remarks>
/// The default implementation delegates to
/// <see cref="Resolve(string, NodeType, AddressScope)"/>.
/// </remarks>
public override INode Resolve(string name, NodeType nodeType, AddressScope scope)
{
return(this.NodeResolver.Resolve(name, nodeType, scope));
}
public override INode Resolve(string name, NodeType nodeType, AddressScope scope)
{
var nodeAddress = base.ResolveAddress(name, scope);
if (nodeAddress.IsDescendentOf(this.Address, AddressScope.Descendent))
{
INode jumpPointNode;
if (jumpPoints.TryGetValue(name, out jumpPointNode))
{
var relativePath = this.Address.GetRelativePathTo(nodeAddress);
if (relativePath == name)
{
return jumpPointNode;
}
else if (jumpPointNode.NodeType == NodeType.Directory)
{
return jumpPointNode.Resolve(relativePath);
}
}
}
return base.Resolve(nodeAddress, nodeType, scope);
}
public override INode Resolve(string uri, NodeType nodeType, AddressScope scope)
{
return Resolve(uri, nodeType, scope, FileSystemOptions.Default);
}
public virtual INodeAddress ResolveAddress(string name, AddressScope scope)
{
return this.Wrappee.ResolveAddress(name, scope);
}
public override INode Resolve(string uri, NodeType nodeType, AddressScope scope)
{
return this.resolver.Resolve(uri, nodeType, scope);
}
public virtual bool IsDescendentOf(INodeAddress name, StringComparison comparisonType, AddressScope scope)
{
return CheckPathScope(name.AbsolutePath, this.AbsolutePath, comparisonType, scope);
}
public Address(AddressScope scope, ushort block, ushort page) : this(scope, block, page, 0)
{
}
private bool CheckPathScope(string basePath, string comparePath, AddressScope scope)
{
return CheckPathScope(basePath, comparePath, StringComparison.CurrentCulture, scope);
}
public virtual IFile ResolveFile(string name, AddressScope scope)
{
return (IFile)Resolve(name, NodeType.File, scope);
}
private bool CheckPathScope(string basePath, string comparePath, StringComparison comparisonType, AddressScope scope)
{
if (scope == AddressScope.FileSystem)
{
return true;
}
if (!comparePath.StartsWith(basePath, comparisonType))
{
return false;
}
var baseLength = basePath.Length;
switch (scope)
{
case AddressScope.Child:
if (/* ComparePath is the same as BasePath */
comparePath.Length == baseLength
/* ComparePath has same parent as base path but different short name */
|| (baseLength > 1 && comparePath[baseLength] != FileSystemManager.SeperatorChar)
/* ComparePath is a (grand)*child of basePath */
|| comparePath.IndexOf(FileSystemManager.SeperatorChar, baseLength + 1) >= 0)
{
return false;
}
break;
case AddressScope.Descendent:
if (/* ComparePath is the same as base path */
comparePath.Length == baseLength
/* ComparePath has same parent as base path but different short name */
|| (baseLength > 1 && comparePath[baseLength] != FileSystemManager.SeperatorChar))
{
return false;
}
break;
case AddressScope.DescendentOrSelf:
if (
/* ComparePath has same parent as base path but different short name */
baseLength > 1
&& comparePath.Length > baseLength
&& comparePath[baseLength] != FileSystemManager.SeperatorChar )
{
return false;
}
break;
default:
return false;
}
return true;
}
public abstract INode Resolve(string name, NodeType nodeType, AddressScope scope);
public virtual bool IsDescendentOf(INodeAddress name, AddressScope scope)
{
return this.Wrappee.IsDescendentOf(name, scope);
}
public override INode Resolve(string uri, NodeType nodeType, AddressScope scope)
{
return(this.resolver.Resolve(uri, nodeType, scope));
}
public virtual INodeAddress ResolveAddress(string name, AddressScope scope)
{
int x;
var query = "";
if (name.Length == 0 || (name.Length > 0 && name[0] != FileSystemManager.RootChar))
{
// Path is relative.
if (this.IsRoot)
{
name = FileSystemManager.RootChar + name;
}
else
{
name = this.absolutePath + FileSystemManager.SeperatorChar + name;
}
}
if ((x = name.IndexOf('?')) >= 0)
{
query = name.Substring(x + 1);
name = name.Substring(0, x);
}
name = StringUriUtils.NormalizePath(name);
if (!CheckPathScope(this.AbsolutePath, name, scope))
{
throw new AddressScopeValidationException(name, scope);
}
return CreateAddress(name, query);
}
/// <summary>
/// <see cref="IResolver.Resolve(string, NodeType, AddressScope)"/>
/// </summary>
public override INode Resolve(string name, NodeType nodeType, AddressScope scope)
{
var address = this.Address.ResolveAddress(name, scope);
return this.FileSystem.Resolve(address, nodeType);
}
public virtual bool IsDescendentOf(INodeAddress name, AddressScope scope)
{
return CheckPathScope(name.AbsolutePath, this.AbsolutePath, scope);
}
