/
AbstractVirtualFileBase.cs
224 lines (184 loc) · 8.11 KB
/
AbstractVirtualFileBase.cs
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Threading;
using System.Threading.Tasks;
using ServiceStack.IO;
using ServiceStack.Text;
using ServiceStack.VirtualPath;
namespace ServiceStack.VirtualPath
{
public abstract class AbstractVirtualFileBase : IVirtualFile
{
public static List<string> ScanSkipPaths { get; set; } = new List<string>();
public IVirtualPathProvider VirtualPathProvider { get; set; }
public virtual string Extension => Name.LastRightPart('.');
public IVirtualDirectory Directory { get; set; }
public abstract string Name { get; }
public virtual string VirtualPath => GetVirtualPathToRoot();
public virtual string RealPath => GetRealPathToRoot();
public virtual bool IsDirectory => false;
public abstract DateTime LastModified { get; }
public abstract long Length { get; }
protected AbstractVirtualFileBase(IVirtualPathProvider owningProvider, IVirtualDirectory directory)
{
this.VirtualPathProvider = owningProvider ?? throw new ArgumentNullException(nameof(owningProvider));
this.Directory = directory ?? throw new ArgumentNullException(nameof(directory));
}
public virtual string GetFileHash()
{
using var stream = OpenRead();
return stream.ToMd5Hash();
}
public virtual StreamReader OpenText()
{
return new StreamReader(OpenRead());
}
public virtual string ReadAllText()
{
using var reader = OpenText();
var text = reader.ReadToEnd();
return text;
}
public virtual byte[] ReadAllBytes()
{
var contents = GetContents();
var bytes = contents is ReadOnlyMemory<byte> rom
? rom.ToArray()
: contents is ReadOnlyMemory<char> romChars
? MemoryProvider.Instance.ToUtf8(romChars.Span).ToArray()
: contents is string s
? MemoryProvider.Instance.ToUtf8(s.AsSpan()).ToArray()
: ReadAllBytes();
return bytes;
}
public virtual async Task<string> ReadAllTextAsync(CancellationToken token = default)
{
using var reader = OpenText();
var text = await reader.ReadToEndAsync();
return text;
}
public virtual Task<byte[]> ReadAllBytesAsync(CancellationToken token = default) => Task.FromResult(ReadAllBytes());
public abstract Stream OpenRead();
public virtual object GetContents()
{
using var stream = OpenRead();
var romBytes = stream.ReadFullyAsMemory();
if (MimeTypes.IsBinary(MimeTypes.GetMimeType(Extension)))
return romBytes;
return MemoryProvider.Instance.FromUtf8(romBytes.Span);
}
protected virtual string GetVirtualPathToRoot()
{
return GetPathToRoot(VirtualPathProvider.VirtualPathSeparator, p => p.VirtualPath);
}
protected virtual string GetRealPathToRoot()
{
return GetPathToRoot(VirtualPathProvider.RealPathSeparator, p => p.RealPath);
}
protected virtual string GetPathToRoot(string separator, Func<IVirtualDirectory, string> pathSel)
{
var parentPath = Directory != null ? pathSel(Directory) : string.Empty;
if (parentPath == separator)
parentPath = string.Empty;
return parentPath == null
? Name
: string.Concat(parentPath, separator, Name);
}
public override bool Equals(object obj)
{
if (!(obj is AbstractVirtualFileBase other))
return false;
return other.VirtualPath == this.VirtualPath;
}
public override int GetHashCode()
{
return VirtualPath.GetHashCode();
}
public override string ToString()
{
return $"{RealPath} -> {VirtualPath}";
}
public virtual void Refresh()
{
}
public virtual async Task WritePartialToAsync(Stream toStream, long start, long end, CancellationToken token = default)
{
using var fs = OpenRead();
await fs.WritePartialToAsync(toStream, start, end, token).ConfigAwait();
}
}
}
namespace ServiceStack
{
public static class VirtualFileExtensions
{
public static bool ShouldSkipPath(this IVirtualNode node)
{
foreach (var skipPath in AbstractVirtualFileBase.ScanSkipPaths)
{
if (node.VirtualPath.StartsWith(skipPath.TrimStart('/'), StringComparison.OrdinalIgnoreCase))
return true;
}
return false;
}
public static IVirtualFile AssertFile(this IVirtualPathProvider vfs, string path)
{
if (vfs == null)
throw new ArgumentNullException(nameof(vfs));
var file = vfs.GetFile(path);
if (file == null)
throw new FileNotFoundException($"File does not exist {vfs.GetType().Name}:{path}");
return file;
}
public static IVirtualDirectory[] GetAllRootDirectories(this IVirtualPathProvider vfs) => vfs is MultiVirtualFiles mvfs
? mvfs.ChildProviders.Select(x => x.RootDirectory).ToArray()
: new[] { vfs.RootDirectory };
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static T GetVirtualFileSource<T>(this IVirtualPathProvider vfs) where T : class => vfs as T ??
(vfs is MultiVirtualFiles mvfs ? mvfs.ChildProviders.FirstOrDefault(x => x is T) as T : null);
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static MemoryVirtualFiles GetMemoryVirtualFiles(this IVirtualPathProvider vfs) =>
vfs.GetVirtualFileSource<MemoryVirtualFiles>();
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static FileSystemVirtualFiles GetFileSystemVirtualFiles(this IVirtualPathProvider vfs) =>
vfs.GetVirtualFileSource<FileSystemVirtualFiles>();
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static GistVirtualFiles GetGistVirtualFiles(this IVirtualPathProvider vfs) =>
vfs.GetVirtualFileSource<GistVirtualFiles>();
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static ResourceVirtualFiles GetResourceVirtualFiles(this IVirtualPathProvider vfs) =>
vfs.GetVirtualFileSource<ResourceVirtualFiles>();
[Obsolete("Use ReadAllTextAsMemory()")]
public static ReadOnlyMemory<char> GetTextContentsAsMemory(this IVirtualFile file) => ReadAllTextAsMemory(file);
public static ReadOnlyMemory<char> ReadAllTextAsMemory(this IVirtualFile file)
{
var contents = file.GetContents();
var span = contents is ReadOnlyMemory<char> rom
? rom
: contents is string s
? s.AsMemory()
: file.ReadAllText().AsMemory();
return span;
}
[Obsolete("Use ReadAllBytesAsMemory()")]
public static ReadOnlyMemory<byte> GetBytesContentsAsMemory(this IVirtualFile file) => ReadAllBytesAsMemory(file);
public static ReadOnlyMemory<byte> ReadAllBytesAsMemory(this IVirtualFile file)
{
var contents = file.GetContents();
var span = contents is ReadOnlyMemory<byte> rom
? rom
: contents is ReadOnlyMemory<char> romChars
? MemoryProvider.Instance.ToUtf8(romChars.Span)
: contents is string s
? MemoryProvider.Instance.ToUtf8(s.AsSpan())
: file.ReadAllBytes().AsMemory();
return span;
}
[Obsolete("Use ReadAllBytes()")]
public static byte[] GetBytesContentsAsBytes(this IVirtualFile file) => file.ReadAllBytes();
}
}