IFileSystem fs = new FileSystem(@"C:\Temp\");

IDirectoryContent contents = fs.Browse("C:/Windows/");

foreach (IEntry entry in fs.Browse("C:/Windows/"))
    Console.WriteLine(entry.Path);

foreach (var entry in fs.Browse("C:/Windows/").AssertExists())
    Console.WriteLine(entry.Path);

IEntry e = FileSystem.OS.GetEntry("C:/Windows/win.ini");
Console.WriteLine(e.Path);

IEntry e = FileSystem.OS.GetEntry("C:/Windows/win.ini").AssertExists();

using (Stream s = fs.Open("file.txt", FileMode.Open, FileAccess.Read, FileShare.Read))
{
    Console.WriteLine(s.Length);
}

using (Stream s = fs.Open("somefile.txt", FileMode.OpenOrCreate, FileAccess.ReadWrite, FileShare.ReadWrite))
{
    s.WriteByte(32);
}

fs.CreateDirectory("dir/");

fs.Delete("dir/", recurse: true);

fs.CreateDirectory("dir/");
fs.Move("dir/", "new-name/");

fs.SetFileAttribute("myfile", FileAttributes.ReadOnly);

IFileSystem fs = FileSystem.OS;

foreach (var line in FileSystem.OS.VisitTree(depth: 2))
    Console.WriteLine(line);

FileSystem.OS.PrintTo(Console.Out, depth: 2, format: PrintTree.Format.DefaultPath);

FileSystem.OS.PrintTo(Console.Out, depth: 3, format: PrintTree.Format.DefaultPath);

FileSystem.Application.PrintTo(Console.Out);

FileSystem.Temp.PrintTo(Console.Out, depth: 1);

foreach(var line in FileSystem.Temp.VisitTree(depth:2))
    Console.WriteLine(line.Entry.PhysicalPath());

FileSystem.Temp.PrintTo(
    output: Console.Out, 
    depth: 2, 
    format: PrintTree.Format.Default | PrintTree.Format.PhysicalPath);

IObserver<IEvent> observer = new Observer();
IFileSystemObserver handle = FileSystem.OS.Observe("C:/**", observer);

using (var handle = FileSystem.Temp.Observe("*.dat", new PrintObserver()))
{
    FileSystem.Temp.CreateFile("file.dat", new byte[] { 32, 32, 32, 32 });
    FileSystem.Temp.Delete("file.dat");

    Thread.Sleep(1000);
}

class PrintObserver : IObserver<IEvent>
{
    public void OnCompleted() => Console.WriteLine("OnCompleted");
    public void OnError(Exception error) => Console.WriteLine(error);
    public void OnNext(IEvent @event) => Console.WriteLine(@event);
}

// Init
object obj = new ReaderWriterLockSlim();
IFileSystemDisposable fs = new FileSystem("").AddDisposable(obj);

// ... do work ...

// Dispose both
fs.Dispose();

IFileSystemDisposable fs = new FileSystem("")
    .AddDisposeAction(f => Console.WriteLine("Disposed"));

FileSystem fs = new FileSystem("");
fs.Browse("");

// Postpone dispose
IDisposable belateDisposeHandle = fs.BelateDispose();
// Start concurrent work
Task.Run(() =>
{
    // Do work
    Thread.Sleep(1000);
    fs.GetEntry("");
    // Release belate handle. Disposes here or below, depending which thread runs last.
    belateDisposeHandle.Dispose();
});

// Start dispose, but postpone it until belatehandle is disposed in another thread.
fs.Dispose();

IFileSystem vfs = new VirtualFileSystem();

IFileSystem vfs = new VirtualFileSystem()
    .Mount("", FileSystem.OS);

IFileSystem urls = new VirtualFileSystem()
    .Mount("tmp/", FileSystem.Temp)
    .Mount("ram/", MemoryFileSystem.Instance);

IFileSystem vfs = new VirtualFileSystem()
    .Mount("", FileSystem.OS)
    .Mount("/tmp/", new MemoryFileSystem());

vfs.Browse("/tmp/");

IFileSystem vfs = new VirtualFileSystem();
vfs.Mount("/tmp/", FileSystem.Temp);
vfs.Unmount("/tmp/");

IFileSystem vfs = new VirtualFileSystem();
vfs.Mount("/tmp/", FileSystem.Temp);
vfs.Mount("/tmp/", new MemoryFileSystem());

IFileSystem vfs = new VirtualFileSystem();
vfs.Mount("/app/", FileSystem.Application, Option.ReadOnly);

IFileSystem vfs = new VirtualFileSystem();
string appDir = AppDomain.CurrentDomain.BaseDirectory.Replace('\\', '/');
vfs.Mount("/app/", FileSystem.OS, Option.SubPath(appDir));

IFileSystem vfs = new VirtualFileSystem();
IFileSystem overrides = new MemoryFileSystem();
overrides.CreateFile("important.dat", new byte[] { 12, 23, 45, 67, 89 });
vfs.Mount("/app/", overrides, FileSystem.Application);

IFileSystem overrides = new MemoryFileSystem();
IFileSystem vfs = new VirtualFileSystem();

vfs.Mount("/app/", 
    (overrides, Option.ReadOnly), 
    (FileSystem.Application, Option.ReadOnly)
);

IFileSystem vfs = new VirtualFileSystem();
vfs.Mount("/tmp/", filesystem: null);

IFileSystem vfs = new VirtualFileSystem();
vfs.Observe("**", new PrintObserver());

IFileSystem ram = new MemoryFileSystem();
ram.CreateDirectory("/dir/");
ram.CreateFile("/dir/file.txt", new byte[] { 32, 65, 66 });

vfs.Mount("", ram);

class PrintObserver : IObserver<IEvent>
{
    public void OnCompleted() => Console.WriteLine("OnCompleted");
    public void OnError(Exception error) => Console.WriteLine(error);
    public void OnNext(IEvent @event) => Console.WriteLine(@event);
}

IFileSystem vfs = new VirtualFileSystem();
vfs.Observe("/dir/*.txt", new PrintObserver());

IFileSystem ram = new MemoryFileSystem();
ram.CreateDirectory("/dir/");
ram.CreateFile("/dir/file.txt", new byte[] { 32, 65, 66 });
ram.CreateFile("/dir/file.dat", new byte[] { 255, 255, 255 });

vfs.Mount("", ram);

vfs.Unmount("");

vfs.Mount("", ram, Option.NoObserve);

IDisposable observerHandle = vfs.Observe("**", new PrintObserver());
observerHandle.Dispose();

VirtualFileSystem vfs = new VirtualFileSystem();
IDisposable observerHandle = vfs.Observe("**", new PrintObserver());
vfs.Dispose();

new VirtualFileSystem.NonDisposable()
    .Mount("file://", FileSystem.OS)                  // All files
    .Mount("tmp://", FileSystem.Temp)                 // Temp files
    .Mount("ram://", MemoryFileSystem.Instance)       // Application's internal ram drive
    .Mount("home://", FileSystem.Personal)            // User's home directory
    .Mount("document://", FileSystem.MyDocuments)     // User's documents
    .Mount("desktop://", FileSystem.Desktop)          // User's desktop
    .Mount("picture://", FileSystem.MyPictures)       // User's pictures
    .Mount("video://", FileSystem.MyVideos)           // User's videos
    .Mount("music://", FileSystem.MyMusic)            // User's music
    .Mount("config://", FileSystem.Config)            // User's cloud-sync program configuration (roaming data).
    .Mount("data://", FileSystem.Data)                // User's local program data.
    .Mount("program-data://", FileSystem.ProgramData) // Program data that is shared with every user.
    .Mount("application://", FileSystem.Application)  // Application's install directory
    .Mount("http://", HttpFileSystem.Instance, Option.SubPath("http://"))
    .Mount("https://", HttpFileSystem.Instance, Option.SubPath("https://"))

VirtualFileSystem.Url.PrintTo(Console.Out, "config://", 2, PrintTree.Format.DefaultPath);
VirtualFileSystem.Url.PrintTo(Console.Out, "data://", 1, PrintTree.Format.DefaultPath);
VirtualFileSystem.Url.PrintTo(Console.Out, "program-data://", 1, PrintTree.Format.DefaultPath);
VirtualFileSystem.Url.PrintTo(Console.Out, "home://", 1, PrintTree.Format.DefaultPath);
VirtualFileSystem.Url.PrintTo(Console.Out, "https://github.com/tagcode/Lexical.FileSystem/tree/master/");

string config = "[Config]\nUser=ExampleUser\n";
VirtualFileSystem.Url.CreateDirectory("config://ApplicationName/");
VirtualFileSystem.Url.CreateFile("config://ApplicationName/config.ini", UTF8Encoding.UTF8.GetBytes(config));

byte[] cacheData = new byte[] { 1, 2, 3, 4, 5, 6, 7, 8 };
VirtualFileSystem.Url.CreateDirectory("data://ApplicationName/");
VirtualFileSystem.Url.CreateFile("data://ApplicationName/cache.db", cacheData);

string saveGame = "[Save]\nLocation=12.32N 43.43W\n";
VirtualFileSystem.Url.CreateDirectory("document://ApplicationName/");
VirtualFileSystem.Url.CreateFile("document://ApplicationName/save1.txt", UTF8Encoding.UTF8.GetBytes(saveGame));

byte[] programData = new byte[] { 1, 2, 3, 4, 5, 6, 7, 8 };
VirtualFileSystem.Url.CreateDirectory("program-data://ApplicationName/");
VirtualFileSystem.Url.CreateFile("program-data://ApplicationName/index.db", programData);

VirtualFileSystem.Url.PrintTo(Console.Out, "application://", format: PrintTree.Format.DefaultPath);

// Init
object obj = new ReaderWriterLockSlim();
IFileSystemDisposable vfs = new VirtualFileSystem().AddDisposable(obj);

// ... do work ...

// Dispose both
vfs.Dispose();

IFileSystemDisposable vfs = new VirtualFileSystem()
    .AddDisposeAction(f => Console.WriteLine("Disposed"));

VirtualFileSystem vfs = new VirtualFileSystem().Mount("", FileSystem.OS);
vfs.Browse("");

// Postpone dispose
IDisposable belateDisposeHandle = vfs.BelateDispose();
// Start concurrent work
Task.Run(() =>
{
    // Do work
    Thread.Sleep(1000);
    vfs.GetEntry("");
    // Release belate handle. Disposes here or below, depending which thread runs last.
    belateDisposeHandle.Dispose();
});

// Start dispose, but postpone it until belatehandle is disposed in another thread.
vfs.Dispose();

IFileSystemDisposable vfs =
    new VirtualFileSystem()
    .Mount("", new FileSystem(""))
    .Mount("/tmp/", new MemoryFileSystem())
    .AddMountsToBeDisposed();

IFileSystem ram = new MemoryFileSystem();
IFileSystem rom = ram.Decorate(Option.ReadOnly);

IFileSystem rom = ram.AsReadOnly();

IFileSystem invisible = ram.Decorate(Option.NoBrowse);

IFileSystem ram = new MemoryFileSystem();
ram.CreateDirectory("tmp/dir/");
ram.CreateFile("tmp/dir/file.txt", new byte[] { 32,32,32,32,32,32,32,32,32 });

IFileSystem tmp = ram.Decorate(Option.SubPath("tmp/"));
tmp.PrintTo(Console.Out, format: PrintTree.Format.DefaultPath);

MemoryFileSystem ram = new MemoryFileSystem();
IFileSystemDisposable rom = ram.Decorate(Option.ReadOnly).AddSourceToBeDisposed();
// Do work ...
rom.Dispose();

MemoryFileSystem ram = new MemoryFileSystem();
ram.CreateDirectory("tmp/dir/");
ram.CreateFile("tmp/dir/file.txt", new byte[] { 32, 32, 32, 32, 32, 32, 32, 32, 32 });
IFileSystemDisposable rom = ram.Decorate(Option.ReadOnly).AddDisposable(ram);
// Do work ...
rom.Dispose();

// Create ram filesystem
MemoryFileSystem ram = new MemoryFileSystem();
ram.CreateDirectory("tmp/dir/");
ram.CreateFile("tmp/dir/file.txt", new byte[] { 32, 32, 32, 32, 32, 32, 32, 32, 32 });

// Create decorations
IFileSystemDisposable rom = ram.Decorate(Option.ReadOnly).AddDisposable(ram.BelateDispose());
IFileSystemDisposable tmp = ram.Decorate(Option.SubPath("tmp/")).AddDisposable(ram.BelateDispose());
ram.Dispose(); // <- is actually postponed

// Do work ...

// Dispose rom1 and tmp, disposes ram as well
rom.Dispose();
tmp.Dispose();

IFileSystem ram = new MemoryFileSystem();
IFileSystem os = FileSystem.OS;
IFileSystem fp = new PhysicalFileProvider(AppDomain.CurrentDomain.BaseDirectory).ToFileSystem()
    .AddDisposeAction(fs=>fs.FileProviderDisposable?.Dispose());
IFileSystem embedded = new EmbeddedFileSystem(typeof(Composition_Examples).Assembly);

IFileSystem composition = FileSystemExtensions.Concat(ram, os, fp, embedded)
    .AddDisposable(embedded)
    .AddDisposable(fp)
    .AddDisposable(os);

foreach (var entry in composition.VisitTree(depth: 1))
    Console.WriteLine(entry);

using (Stream s = composition.Open("docs.example-file.txt", FileMode.Open, FileAccess.Read, FileShare.Read))
{
    Console.WriteLine(s.Length);
}

IFileSystem ram1 = new MemoryFileSystem();
IFileSystem ram2 = new MemoryFileSystem();
IFileSystem composition = FileSystemExtensions.Concat(ram1, ram2);

// Create file of 1024 bytes
ram1.CreateFile("file.txt", new byte[1024]);

// Create file of 10 bytes
ram2.CreateFile("file.txt", new byte[10]);

// Get only one entry size of 1024 bytes.
composition.PrintTo(Console.Out, format: PrintTree.Format.Default | PrintTree.Format.Length);

IFileSystem filesystem = FileSystem.Application;
IFileSystem overrides = new MemoryFileSystem();
IFileSystem composition = FileSystemExtensions.Concat(
    (filesystem, null), 
    (overrides, Option.ReadOnly)
);

IFileSystem fs = new PhysicalFileProvider(@"C:\Users").ToFileSystem();

IFileProvider fp = new PhysicalFileProvider(@"C:\");
IFileSystem fs = fp.ToFileSystem(
    canBrowse: true,
    canObserve: true,
    canOpen: true);

IFileProvider fp = new PhysicalFileProvider(@"C:\Users");
IFileSystemDisposable filesystem = fp.ToFileSystem().AddDisposable(fp);

IFileSystemDisposable filesystem = new PhysicalFileProvider(@"C:\Users")
    .ToFileSystem()
    .AddDisposeAction(fs => fs.FileProviderDisposable?.Dispose());

using (var fs = new PhysicalFileProvider(@"C:\Users")
    .ToFileSystem()
    .AddDisposeAction(f => f.FileProviderDisposable?.Dispose()))
{
    fs.Browse("");

    // Post pone dispose at end of using()
    IDisposable belateDisposeHandle = fs.BelateDispose();
    // Start concurrent work
    Task.Run(() =>
    {
        // Do work
        Thread.Sleep(100);
        fs.GetEntry("");

        // Release the belate dispose handle
        // FileSystem is actually disposed here
        // provided that the using block has exited
        // in the main thread.
        belateDisposeHandle.Dispose();
    });

    // using() exists here and starts the dispose fs
}

IFileSystem fs = new PhysicalFileProvider(@"C:\Users").ToFileSystem();
foreach (var line in fs.VisitTree(depth: 2))
    Console.WriteLine(line);

IFileSystem fs = new PhysicalFileProvider(@"C:\Users").ToFileSystem();
IObserver<IEvent> observer = new Observer();
using (IDisposable handle = fs.Observe("**", observer))
{
}

IFileProvider fp = FileSystem.OS.ToFileProvider();

IFileSystem fs = new FileSystem("");
IFileProviderDisposable fp = fs.ToFileProvider().AddDisposable(fs);

IFileProviderDisposable fp = new FileSystem("")
    .ToFileProvider()
    .AddDisposeAction(fs => fs.FileSystemDisposable?.Dispose());

using (var fp = new FileSystem("").ToFileProvider()
        .AddDisposeAction(fs => fs.FileSystemDisposable?.Dispose()))
{
    fp.GetDirectoryContents("");

    // Post pone dispose at end of using()
    IDisposable belateDisposeHandle = fp.BelateDispose();
    // Start concurrent work
    Task.Run(() =>
    {
        // Do work
        Thread.Sleep(100);
        fp.GetDirectoryContents("");

        // Release the belate dispose handle
        // FileSystem is actually disposed here
        // provided that the using block has exited
        // in the main thread.
        belateDisposeHandle.Dispose();
    });

    // using() exists here and starts the dispose fs
}

IFileProvider fp = FileSystem.OS.ToFileProvider();
foreach (var fi in fp.GetDirectoryContents(""))
    Console.WriteLine(fi.Name);

IChangeToken token = new FileSystem(@"c:").ToFileProvider().Watch("**");
token.RegisterChangeCallback(o => Console.WriteLine("Changed"), null);

IFileSystem filesystem = new MemoryFileSystem();

IFileSystem filesystem = new MemoryFileSystem(blockSize: 4096);

foreach (var entry in filesystem.Browse(""))
    Console.WriteLine(entry.Path);

using (Stream s = filesystem.Open("file.txt", FileMode.Open, FileAccess.Read, FileShare.Read))
{
    Console.WriteLine(s.Length);
}

using (Stream s = filesystem.Open("file.txt", FileMode.OpenOrCreate, FileAccess.ReadWrite, FileShare.ReadWrite))
{
    s.WriteByte(32);
}

IObserver<IEvent> observer = new Observer();
using (IDisposable handle = filesystem.Observe("**", observer))
{
}

filesystem.CreateDirectory("dir/");

filesystem.CreateDirectory("dir1/dir2/dir3/");
filesystem.PrintTo(Console.Out);

filesystem.CreateDirectory("/tmp/dir/");

filesystem.CreateDirectory("file://");

filesystem.Delete("dir/", recurse: true);

filesystem.CreateDirectory("dir/");
filesystem.Move("dir/", "new-name/");

// Init
object obj = new ReaderWriterLockSlim();
IFileSystemDisposable filesystem = new FileSystem("").AddDisposable(obj);

// ... do work ...

// Dispose both
filesystem.Dispose();

IFileSystemDisposable filesystem = new FileSystem("")
    .AddDisposeAction(f => Console.WriteLine("Disposed"));

MemoryFileSystem filesystem = new MemoryFileSystem();
filesystem.CreateDirectory("/tmp/dir/");

// Postpone dispose
IDisposable belateDisposeHandle = filesystem.BelateDispose();
// Start concurrent work
Task.Run(() =>
{
    // Do work
    Thread.Sleep(1000);
    filesystem.GetEntry("");
    // Release belate handle. Disposes here or below, depending which thread runs last.
    belateDisposeHandle.Dispose();
});

// Start dispose, but postpone it until belatehandle is disposed in another thread.
filesystem.Dispose();

IFileSystem ms = new MemoryFileSystem(blockSize: 1024, maxSpace: 1L << 34);

IFileSystem ms = new MemoryFileSystem(blockSize: 1024, maxSpace: 1L << 34);
ms.CreateFile("file", new byte[1 << 30]);
ms.PrintTo(Console.Out, format: PrintTree.Format.AllWithName);

IFileSystem ms = new MemoryFileSystem(blockSize: 1024, maxSpace: 2048);
ms.CreateFile("file1", new byte[1024]);
ms.CreateFile("file2", new byte[1024]);

// throws FileSystemExceptionOutOfDiskSpace
ms.CreateFile("file3", new byte[1024]);

IBlockPool pool = new BlockPool(blockSize: 1024, maxBlockCount: 3, maxRecycleQueue: 3);
IFileSystem ms1 = new MemoryFileSystem(pool);
IFileSystem ms2 = new MemoryFileSystem(pool);

// Reserve 2048 from shared pool
ms1.CreateFile("file1", new byte[2048]);

// Not enough for another 3072, throws FileSystemExceptionOutOfDiskSpace
ms2.CreateFile("file2", new byte[2048]);

IBlockPool pool = new BlockPool(blockSize: 1024, maxBlockCount: 3, maxRecycleQueue: 3);
IFileSystem ms = new MemoryFileSystem(pool);
Stream s = ms.Open("file", FileMode.Create, FileAccess.ReadWrite, FileShare.ReadWrite);
s.Write(new byte[3072], 0, 3072);
ms.Delete("file");

Console.WriteLine(pool.BytesAvailable); // Prints 0
s.Dispose();
Console.WriteLine(pool.BytesAvailable); // Prints 3072

IFileSystem fs = new HttpFileSystem(httpClient: default, option: default);

IFileSystem fs = HttpFileSystem.Instance;

using (var s = HttpFileSystem.Instance.Open("http://lexical.fi/", FileMode.Open, FileAccess.Read, FileShare.None))
{
    byte[] data = StreamUtils.ReadFully(s);
    String str = UTF8Encoding.UTF8.GetString(data);
    Console.WriteLine(str);
}

MemoryFileSystem ram = new MemoryFileSystem();
HttpFileSystem.Instance.CopyFile("http://lexical.fi", ram, "document.txt");
ram.PrintTo(Console.Out);

byte[] data = new byte[1024];
using (var s = HttpFileSystem.Instance.Open("http://lexical.fi/", FileMode.Create, FileAccess.Write, FileShare.None))
    s.Write(data);

// Create options
List<KeyValuePair<string, IEnumerable<string>>> headers = new List<KeyValuePair<string, IEnumerable<string>>>();
headers.Add(new KeyValuePair<string, IEnumerable<string>>("User-Agent", new String[] { "MyUserAgent" }));
IOption option1 = new Token(headers, typeof(System.Net.Http.Headers.HttpHeaders).FullName);
IOption option2 = Option.SubPath("http://lexical.fi/");
IOption options = Option.Union(option1, option2);

// Create FileSystem
IFileSystem fs = new HttpFileSystem(option: options);

// Read resource
using (var s = fs.Open("index.html", FileMode.Open, FileAccess.Read, FileShare.None))
{
    byte[] data = StreamUtils.ReadFully(s);
    String str = UTF8Encoding.UTF8.GetString(data);
    Console.WriteLine(str);
}

AuthenticationHeaderValue authentication = new AuthenticationHeaderValue("Basic", Convert.ToBase64String(UTF8Encoding.UTF8.GetBytes($"webuser:webpassword")));
IToken token = new Token(authentication, typeof(AuthenticationHeaderValue).FullName);
using (var s = HttpFileSystem.Instance.Open("https://lexical.fi/public/Lexical.FileSystem/private/document.txt", FileMode.Open, FileAccess.Read, FileShare.None, token))
{
    byte[] data = new byte[4096];
    int c = s.Read(data, 0, 1024);
    String str = UTF8Encoding.UTF8.GetString(data, 0, c);
    Console.WriteLine(str);
}

// Authentication header
AuthenticationHeaderValue authentication = new AuthenticationHeaderValue("Basic", Convert.ToBase64String(UTF8Encoding.UTF8.GetBytes($"webuser:webpassword")));

// Token
IToken token = new Token(
    authentication, 
    typeof(AuthenticationHeaderValue).FullName,
    "https://lexical.fi/public/Lexical.FileSystem/private/**",
    "https://www.lexical.fi/public/Lexical.FileSystem/private/**"
);

// Create FileSystem
IFileSystem fs = new HttpFileSystem(default, token);

// Open
using (var s = fs.Open("https://lexical.fi/public/Lexical.FileSystem/private/document.txt", FileMode.Open, FileAccess.Read, FileShare.None))
{
    byte[] data = new byte[4096];
    int c = s.Read(data, 0, 1024);
    String str = UTF8Encoding.UTF8.GetString(data, 0, c);
    Console.WriteLine(str);
}

// Authentication header
AuthenticationHeaderValue authentication = new AuthenticationHeaderValue("Basic", Convert.ToBase64String(UTF8Encoding.UTF8.GetBytes($"webuser:webpassword")));

// Create token
IToken token = new Token(authentication, typeof(AuthenticationHeaderValue).FullName, "https://lexical.fi/public/Lexical.FileSystem/private/**");

// Pass token into decorator
IFileSystem decoration = HttpFileSystem.Instance.Decorate(token);

// Open
using (var s = decoration.Open("https://lexical.fi/public/Lexical.FileSystem/private/document.txt", FileMode.Open, FileAccess.Read, FileShare.None))
{
    byte[] data = new byte[4096];
    int c = s.Read(data, 0, 1024);
    String str = UTF8Encoding.UTF8.GetString(data, 0, c);
    Console.WriteLine(str);
}

HttpFileSystem.Instance.Delete("https://lexical.fi/public/Lexical.FileSystem/private/document.txt");

var authBlob = Convert.ToBase64String(UTF8Encoding.UTF8.GetBytes($"webuser:webpassword"));
var authentication = new AuthenticationHeaderValue("Basic", authBlob);
var token = new Token(authentication, typeof(AuthenticationHeaderValue).FullName, "https://lexical.fi/public/Lexical.FileSystem/private/**");

IEnumerable<IEntry> entries = HttpFileSystem.Instance.Browse("https://lexical.fi/public/Lexical.FileSystem/private/", token);

var authBlob = Convert.ToBase64String(UTF8Encoding.UTF8.GetBytes($"webuser:webpassword"));
var authentication = new AuthenticationHeaderValue("Basic", authBlob);
var token = new Token(authentication, typeof(AuthenticationHeaderValue).FullName, "https://lexical.fi/public/Lexical.FileSystem/private/**");

IEntry entry = HttpFileSystem.Instance.GetEntry("https://lexical.fi/public/Lexical.FileSystem/private/document.txt", token);

var authBlob = Convert.ToBase64String(UTF8Encoding.UTF8.GetBytes($"webuser:webpassword"));
var authentication = new AuthenticationHeaderValue("Basic", authBlob);
var token = new Token(authentication, typeof(AuthenticationHeaderValue).FullName, "https://lexical.fi/public/Lexical.FileSystem/private/**");

HttpFileSystem.Instance.PrintTo(Console.Out, "https://lexical.fi/public/Lexical.FileSystem/private/", option: token);

HttpFileSystem.Instance.PrintTo(Console.Out, "https://github.com/tagcode/Lexical.FileSystem/tree/master/");

// Cancel token
CancellationTokenSource cancelSrc = new CancellationTokenSource();
IToken token = new Token(cancelSrc.Token, typeof(CancellationToken).FullName);

// Set canceled
cancelSrc.Cancel();

// Read
HttpFileSystem.Instance.Open("http://lexical.fi/", FileMode.Open, FileAccess.Read, FileShare.None, token);

IFileSystem fs = new MemoryFileSystem();
fs.CreateDirectory("myfile.zip/folder");
fs.CreateFile("myfile.zip/folder/somefile.txt");

FileScanner filescanner = new FileScanner(fs);

filescanner.AddWildcard("*.zip");

filescanner.AddRegex(path: "", pattern: new Regex(@".*\.zip"));

filescanner.AddGlobPattern("**.zip/**.txt");

filescanner.AddGlobPattern("myfile.zip/**.txt");

foreach (IEntry entry in filescanner)
{
    Console.WriteLine(entry.Path);
}

// Collect errors
filescanner.errors = new ConcurrentBag<Exception>();
// Run scan
IEntry[] entries = filescanner.ToArray();
// View errors
foreach (Exception e in filescanner.errors) Console.WriteLine(e);

filescanner.ReturnDirectories = true;

filescanner.SetDirectoryEvaluator(e => e.Name != "tmp");

IFileSystem ram = new MemoryFileSystem();
ram.CreateDirectory("/tmp/");
ram.CreateDirectory("/mnt/");
ram.CreateDirectory("/usr/lex/");
ram.CreateDirectory("c:/dir/dir/");
ram.CreateFile("/tmp/helloworld.txt", Encoding.UTF8.GetBytes("Hello World!\r\n"));
ram.CreateDirectory("file://c:/temp");

foreach (TreeVisit.Line line in ram.VisitTree())
{
    Console.WriteLine(line);
}

foreach (TreeVisit.Line line in ram.VisitTree(depth: 1))
{
    Console.WriteLine(line);
}

foreach (TreeVisit.Line line in ram.VisitTree(path: "/tmp/"))
{
    Console.WriteLine(line);
}

IFileSystem ram = new MemoryFileSystem();
ram.CreateDirectory("/tmp/");
ram.CreateDirectory("/mnt/");
ram.CreateDirectory("/usr/lex/");
ram.CreateDirectory("c:/dir/dir/");
ram.CreateFile("/tmp/helloworld.txt", Encoding.UTF8.GetBytes("Hello World!\r\n"));
ram.CreateDirectory("file://c:/temp/");

ram.PrintTo(Console.Out);

StringBuilder sb = new StringBuilder();
ram.PrintTo(sb);

Console.WriteLine(ram.Print());

Console.WriteLine(ram.Print(depth:1));

Console.WriteLine(ram.Print(path:"/tmp/"));

string tree =  ram.Print(format: PrintTree.Format.Tree | PrintTree.Format.Path | 
                                 PrintTree.Format.Length | PrintTree.Format.Error);

IFileSystem ms = new MemoryFileSystem();
ms.CreateFile("file", new byte[1024*1024]);

using(var s = new OperationSession())
{
    new CopyFile(s, ms, "file", ms, "file.copy")
        .Estimate()
        .AssertCanRollback()
        .Run()
        .AssertSuccessful();
}

var s = new OperationSession();
var op = new CopyFile(s, ms, "file", ms, "file.copy");
op.Estimate();

Console.WriteLine(op.CanRollback);

op.Estimate().AssertCanRollback();

op.Run();

if (op.CurrentState == OperationState.Completed) 
    Console.WriteLine("ok");

op.Run().AssertSuccessful();

try
{
    op.Run();
}
catch (Exception)
{
    // Rollback
    op.CreateRollback()?.Run();
}

op.Run(rollbackOnError: true);

IFileSystem ms = new MemoryFileSystem();
ms.CreateDirectory("dir/dir/dir/");
ms.CreateFile("dir/dir/dir/file", new byte[1024 * 1024]);

using (var s = new OperationSession())
{
    var op = new CopyTree(s, ms, "dir", ms, "dir.copy");

    op.Estimate().AssertCanRollback().Run().AssertSuccessful();
}

IFileSystem ms = new MemoryFileSystem();                
using (var s = new OperationSession(policy: OperationPolicy.EstimateOnRun/*important*/))
{
    Batch batch = new Batch(s, OperationPolicy.Unset);

    batch.Ops.Add(new CreateDirectory(s, ms, "dir/dir/dir"));
    batch.Ops.Add(new CopyTree(s, ms, "dir", ms, "dir.copy"));
    batch.Ops.Add(new Delete(s, ms, "dir/dir", true, policy: OperationPolicy.EstimateOnRun));
    batch.Estimate().Run().AssertSuccessful();
}

IFileSystem ms_src = new MemoryFileSystem();
ms_src.CreateDirectory("dir/dir/dir/");
ms_src.CreateFile("dir/dir/dir/file", new byte[1024 * 1024]);

IFileSystem ms_dst = new MemoryFileSystem();

using (var s = new OperationSession())
{
    var op = new TransferTree(s, ms_src, "dir", ms_dst, "dir.elsewhere");
    op.Estimate().AssertCanRollback().Run().AssertSuccessful();
}

IFileSystem ms = new MemoryFileSystem();
ms.CreateFile("file", new byte[1024 * 1024]);

using (var s = new OperationSession())
{
    new CopyFile(s, ms, "file", ms, "file.copy")
        .Estimate()
        .AssertCanRollback()
        .Run()
        .AssertSuccessful();

    foreach (var @event in s.Events)
        Console.WriteLine(@event);
}
ms.PrintTo(Console.Out);

IFileSystem ms = new MemoryFileSystem();
ms.CreateFile("file", new byte[1024 * 20]);

using (var s = new OperationSession().SetProgressInterval(1024))
{
    s.Subscribe(new OpEventPrinter());

    new CopyFile(s, ms, "file", ms, "file.copy")
        .Estimate()
        .AssertCanRollback()
        .Run()
        .AssertSuccessful();
}
ms.PrintTo(Console.Out);

class OpEventPrinter : IObserver<IOperationEvent>
{
    public void OnCompleted() => Console.WriteLine("OnCompleted");
    public void OnError(Exception error) => Console.WriteLine(error);
    public void OnNext(IOperationEvent @event) => Console.WriteLine(@event);
}

IFileSystem ms = new MemoryFileSystem();
ms.CreateFile("file", new byte[1024 * 10]);
CancellationTokenSource cancelSrc = new CancellationTokenSource();

using (var s = new OperationSession(cancelSrc: cancelSrc))
{
    cancelSrc.Cancel();
    new Move(s, ms, "file", ms, "file.moved")
        .Estimate()
        .AssertCanRollback()
        .Run()
        .AssertSuccessful();
}