public TextGenerator(
ITemplateLoader templateLoader,
IVirtualFileProvider virtualFileProvider)
{
_templateLoader = templateLoader;
_virtualFileProvider = virtualFileProvider;
}
public EffectCompiler(IVirtualFileProvider fileProvider)
{
FileProvider = fileProvider;
NativeLibrary.PreloadLibrary("d3dcompiler_47.dll");
SourceDirectories = new List <string>();
UrlToFilePath = new Dictionary <string, string>();
}
public AbpComponentDemoSectionTagHelper(
IVirtualFileProvider virtualFileProvider,
IGuidGenerator guidGenerator)
{
_virtualFileProvider = virtualFileProvider;
_guidGenerator = guidGenerator;
}
public FileOdbBackend(string vfsRootUrl, string indexName, bool isReadOnly)
{
var resolveProviderResult = VirtualFileSystem.ResolveProvider(vfsRootUrl, true);
virtualFileProvider = resolveProviderResult.Provider;
this.vfsRootUrl = resolveProviderResult.Path;
vfsTempUrl = this.vfsRootUrl + TempDirectory;
// Ensure directories exists
if (!virtualFileProvider.DirectoryExists(this.vfsRootUrl))
{
virtualFileProvider.CreateDirectory(this.vfsRootUrl);
}
IsReadOnly = isReadOnly;
contentIndexMap = !string.IsNullOrEmpty(indexName) ? Serialization.Contents.ContentIndexMap.Load(vfsRootUrl + VirtualFileSystem.DirectorySeparatorChar + indexName, isReadOnly)
: Serialization.Contents.ContentIndexMap.CreateInMemory();
if (!isReadOnly && !virtualFileProvider.DirectoryExists(vfsTempUrl))
{
try
{
virtualFileProvider.CreateDirectory(vfsTempUrl);
}
catch (Exception)
{
IsReadOnly = true;
}
}
}
public FileOdbBackend(string vfsRootUrl, bool isReadOnly, string indexName = "index")
{
var resolveProviderResult = VirtualFileSystem.ResolveProvider(vfsRootUrl, true);
virtualFileProvider = resolveProviderResult.Provider;
this.vfsRootUrl = resolveProviderResult.Path;
vfsTempUrl = this.vfsRootUrl + "/tmp/";
// Ensure directories exists
if (!virtualFileProvider.DirectoryExists(this.vfsRootUrl))
{
virtualFileProvider.CreateDirectory(this.vfsRootUrl);
}
this.isReadOnly = isReadOnly;
assetIndexMap = Serialization.Assets.AssetIndexMap.Load(vfsRootUrl + VirtualFileSystem.DirectorySeparatorChar + indexName, isReadOnly);
if (!isReadOnly && !virtualFileProvider.DirectoryExists(vfsTempUrl))
{
try
{
virtualFileProvider.CreateDirectory(vfsTempUrl);
}
catch (Exception)
{
this.isReadOnly = true;
}
}
}
/// <inheritdoc/>
public override void FileMove(string sourceUrl, IVirtualFileProvider destinationProvider, string destinationUrl)
{
if (destinationProvider is FileSystemProvider filesystemProvider)
{
filesystemProvider.CreateDirectory(destinationUrl.Substring(0, destinationUrl.LastIndexOf(VirtualFileSystem.DirectorySeparatorChar)));
var sourcePath = ConvertUrlToFullPath(sourceUrl);
var destPath = filesystemProvider.ConvertUrlToFullPath(destinationUrl);
File.Move(sourcePath, destPath);
}
else
{
bool copySuccesful = false;
using (Stream sourceStream = OpenStream(sourceUrl, VirtualFileMode.Open, VirtualFileAccess.Read))
using (Stream destinationStream = destinationProvider.OpenStream(destinationUrl, VirtualFileMode.CreateNew, VirtualFileAccess.Write))
{
sourceStream.CopyTo(destinationStream);
copySuccesful = true;
}
if (copySuccesful)
{
FileDelete(sourceUrl);
}
}
}
public HybridWebRootFileProvider(IVirtualFileProvider virtualFileProvider, IHostingEnvironment hostingEnvironment)
{
_virtualFileProvider = virtualFileProvider;
_hostingEnvironment = hostingEnvironment;
_fileProvider = CreateHybridProvider();
}
public FileOdbBackend(string vfsRootUrl, string indexName, bool isReadOnly)
{
var resolveProviderResult = VirtualFileSystem.ResolveProvider(vfsRootUrl, true);
virtualFileProvider = resolveProviderResult.Provider;
this.vfsRootUrl = resolveProviderResult.Path;
vfsTempUrl = this.vfsRootUrl + TempDirectory;
// Ensure directories exists
if (!virtualFileProvider.DirectoryExists(this.vfsRootUrl))
virtualFileProvider.CreateDirectory(this.vfsRootUrl);
IsReadOnly = isReadOnly;
contentIndexMap = !string.IsNullOrEmpty(indexName) ? Serialization.Contents.ContentIndexMap.Load(vfsRootUrl + VirtualFileSystem.DirectorySeparatorChar + indexName, isReadOnly)
: Serialization.Contents.ContentIndexMap.CreateInMemory();
if (!isReadOnly && !virtualFileProvider.DirectoryExists(vfsTempUrl))
{
try
{
virtualFileProvider.CreateDirectory(vfsTempUrl);
}
catch (Exception)
{
IsReadOnly = true;
}
}
}
public FileOdbBackend(string vfsRootUrl, bool isReadOnly, string indexName = "index")
{
var resolveProviderResult = VirtualFileSystem.ResolveProvider(vfsRootUrl, true);
virtualFileProvider = resolveProviderResult.Provider;
this.vfsRootUrl = resolveProviderResult.Path;
vfsTempUrl = this.vfsRootUrl + "/tmp/";
// Ensure directories exists
if (!virtualFileProvider.DirectoryExists(this.vfsRootUrl))
virtualFileProvider.CreateDirectory(this.vfsRootUrl);
this.isReadOnly = isReadOnly;
assetIndexMap = Serialization.Assets.AssetIndexMap.Load(vfsRootUrl + VirtualFileSystem.DirectorySeparatorChar + indexName, isReadOnly);
if (!isReadOnly && !virtualFileProvider.DirectoryExists(vfsTempUrl))
{
try
{
virtualFileProvider.CreateDirectory(vfsTempUrl);
}
catch (Exception)
{
this.isReadOnly = true;
}
}
}
/// <summary>
/// Add a new file provider
/// </summary>
/// <param name="fileProvider"> </param>
public void Add(IVirtualFileProvider fileProvider)
{
if (fileProvider == null)
{
throw new ArgumentNullException("fileProvider");
}
_fileProviders.Add(fileProvider);
}
public SettingUiAppService(IStringLocalizer <SettingUiResource> localizer, IVirtualFileProvider fileProvider, IJsonSerializer jsonSerializer, ISettingDefinitionManager settingDefinitionManager, ISettingManager settingManager)
{
_localizer = localizer;
_fileProvider = fileProvider;
_jsonSerializer = jsonSerializer;
_settingDefinitionManager = settingDefinitionManager;
_settingManager = settingManager;
}
public TemplatContentsModel(ITemplateDefinitionAppService templateDefinitionAppService,
IVirtualFileProvider virtualFileProvider
, TemplateDefinitionManager templateDefinitionManager)
{
_templateDefinitionAppService = templateDefinitionAppService;
VirtualFileProvider = virtualFileProvider;
_templateDefinitionManager = templateDefinitionManager;
}
public static IEffectCompiler CreateEffectCompiler(
IVirtualFileProvider fileProvider,
EffectSystem effectSystem = null,
string packageName = null,
EffectCompilationMode effectCompilationMode = EffectCompilationMode.Local,
bool recordEffectRequested = false,
TaskSchedulerSelector taskSchedulerSelector = null,
DatabaseFileProvider database = null)
{
EffectCompilerBase compiler = null;
if ((effectCompilationMode & EffectCompilationMode.Local) != 0)
{
// Local allowed and available, let's use that
compiler = new EffectCompiler(fileProvider)
{
SourceDirectories = { EffectCompilerBase.DefaultSourceShaderFolder },
};
}
// Select database - needed for caching
var selectedDatabase = database ?? fileProvider as DatabaseFileProvider;
// Nothing to do remotely
bool needRemoteCompiler = (compiler == null && (effectCompilationMode & EffectCompilationMode.Remote) != 0);
if (needRemoteCompiler || recordEffectRequested)
{
// Create the object that handles the connection
var shaderCompilerTarget = new RemoteEffectCompilerClient(packageName);
if (recordEffectRequested)
{
// Let's notify effect compiler server for each new effect requested
effectSystem.EffectUsed += shaderCompilerTarget.NotifyEffectUsed;
}
// Use remote only if nothing else was found before (i.e. a local compiler)
if (needRemoteCompiler)
{
// Create a remote compiler
compiler = new RemoteEffectCompiler(fileProvider, selectedDatabase, shaderCompilerTarget);
}
else
{
// Otherwise, EffectSystem takes ownership of shaderCompilerTarget
shaderCompilerTarget.DisposeBy(effectSystem);
}
}
// Local not possible or allowed, and remote not allowed either => switch back to null compiler
if (compiler == null)
{
compiler = new NullEffectCompiler(fileProvider, selectedDatabase);
}
return(new EffectCompilerCache(compiler, selectedDatabase, taskSchedulerSelector));
}
public Index(IOptions <AbpLocalizationOptions> abpLocalizationOptions,
ResourceManagerStringLocalizerFactory innerFactory,
ILanguageProvider languageProvider, IVirtualFileProvider virtualFileProvider) : this()
{
this.abpLocalizationOptions = abpLocalizationOptions;
InnerFactory = innerFactory;
LanguageProvider = languageProvider;
VirtualFileProvider = virtualFileProvider;
}
public MappingsLoader(
IVirtualFileProvider virtualFileProvider,
IJsonSerializer jsonSerializer)
{
_virtualFileProvider = virtualFileProvider;
_jsonSerializer = jsonSerializer;
_mappings = new ConcurrentDictionary <DbProviderType, DbTypeMap>();
Initial();
}
/// <summary>
/// Unregisters the specified virtual file provider.
/// </summary>
/// <param name="provider">The provider.</param>
/// <param name="dispose">Indicate that the provider should be disposed, if it inherits from IDisposable interface.</param>
public static void UnregisterProvider(IVirtualFileProvider provider, bool dispose = true)
{
var mountPoints = providers.Where(x => x.Value == provider).ToArray();
foreach (var mountPoint in mountPoints)
{
providers.Remove(mountPoint.Key);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="ShaderMixinParser"/> class.
/// </summary>
public ShaderMixinParser(IVirtualFileProvider fileProvider)
{
SourceManager = new ShaderSourceManager(fileProvider);
var shaderLoader = new ShaderLoader(SourceManager);
if (shaderLibrary == null)
{
shaderLibrary = new StrideShaderLibrary(shaderLoader);
}
}
public ClientProxyApiDescriptionFinder(
IVirtualFileProvider virtualFileProvider,
IJsonSerializer jsonSerializer)
{
VirtualFileProvider = virtualFileProvider;
JsonSerializer = jsonSerializer;
ActionApiDescriptionModels = new Dictionary <string, ActionApiDescriptionModel>();
Initialize();
}
public WebContentFileProvider(
IVirtualFileProvider virtualFileProvider,
IWebHostEnvironment hostingEnvironment,
IOptions <RocketAspNetCoreContentOptions> options)
{
_virtualFileProvider = virtualFileProvider;
_hostingEnvironment = hostingEnvironment;
Options = options.Value;
_fileProvider = CreateFileProvider();
}
public EffectCompiler(IVirtualFileProvider fileProvider)
{
FileProvider = fileProvider;
if (Platform.IsWindowsDesktop && !d3dCompilerLoaded)
{
NativeLibraryHelper.PreloadLibrary("d3dcompiler_47", typeof(EffectCompiler));
d3dCompilerLoaded = true;
}
SourceDirectories = new List <string>();
UrlToFilePath = new Dictionary <string, string>();
}
/// <summary>
/// Registers the specified virtual file provider at the specified mount location.
/// </summary>
/// <param name="provider">The provider.</param>
public static void RegisterProvider(IVirtualFileProvider provider)
{
if (provider.RootPath != null)
{
if (providers.ContainsKey(provider.RootPath))
{
throw new InvalidOperationException(string.Format("A Virtual File Provider with the root path \"{0}\" already exists.", provider.RootPath));
}
providers.Add(provider.RootPath, provider);
}
}
/// <summary>
/// Registers a virtual file provider at the specified mount location.
/// </summary>
/// <param name="provider">The provider to register.</param>
public static void RegisterProvider(IVirtualFileProvider provider)
{
if (provider.RootPath != null)
{
if (providers.ContainsKey(provider.RootPath))
{
throw new InvalidOperationException($@"A Virtual File Provider with the root path ""{provider.RootPath}"" already exists.");
}
providers.Add(provider.RootPath, provider);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="ShaderMixinParser"/> class.
/// </summary>
public ShaderMixinParser(IVirtualFileProvider fileProvider)
{
SourceManager = new ShaderSourceManager(fileProvider);
var shaderLoader = new ShaderLoader(SourceManager);
if (shaderLibrary == null)
{
shaderLibrary = new XenkoShaderLibrary(shaderLoader);
}
// Create the clone context with the instances of Hlsl classes
HlslSemanticAnalysis.FillCloneContext(hlslCloneContext);
}
/// <summary>
/// Initializes a new instance of the <see cref="ShaderMixinParser"/> class.
/// </summary>
public ShaderMixinParser(IVirtualFileProvider fileProvider)
{
SourceManager = new ShaderSourceManager(fileProvider);
var shaderLoader = new ShaderLoader(SourceManager);
if (shaderLibrary == null)
{
shaderLibrary = new ParadoxShaderLibrary(shaderLoader);
}
// Create the clone context with the instances of Hlsl classes
HlslSemanticAnalysis.FillCloneContext(hlslCloneContext);
}
/// <summary>
/// Initializes static members of the <see cref="VirtualFileSystem"/> class.
/// </summary>
static VirtualFileSystem()
{
PlatformFolders.IsVirtualFileSystemInitialized = true;
// TODO: Find a better solution to customize the ApplicationDataDirectory, now we're very limited due to the initialization from a static constructor
ApplicationData = new FileSystemProvider("/data", Path.Combine(PlatformFolders.ApplicationDataDirectory, PlatformFolders.ApplicationDataSubDirectory));
ApplicationCache = new FileSystemProvider("/cache", PlatformFolders.ApplicationCacheDirectory);
ApplicationRoaming = new FileSystemProvider("/roaming", PlatformFolders.ApplicationRoamingDirectory);
ApplicationLocal = new FileSystemProvider("/local", PlatformFolders.ApplicationLocalDirectory);
ApplicationTemporary = new FileSystemProvider("/tmp", PlatformFolders.ApplicationTemporaryDirectory);
ApplicationBinary = new FileSystemProvider("/binary", PlatformFolders.ApplicationBinaryDirectory);
Drive = new DriveFileProvider(DriveFileProvider.DefaultRootPath);
}
//==========================================================================================
/// <summary>
/// This type of DynamicSoundSource is streamed from Disk and reads compressed Celt encoded data, used internally.
/// </summary>
/// <param name="instance">The associated SoundInstance</param>
/// <param name="fileProvider">The file provider to read the stream from</param>
/// <param name="soundStreamUrl">The compressed stream internal URL</param>
/// <param name="numberOfPackets"></param>
/// <param name="sampleRate">The sample rate of the compressed data</param>
/// <param name="channels">The number of channels of the compressed data</param>
/// <param name="maxCompressedSize">The maximum size of a compressed packet</param>
public CompressedSoundSource(SoundInstance instance, IVirtualFileProvider fileProvider, string soundStreamUrl, int numberOfPackets, int sampleRate, int channels, int maxCompressedSize) :
base(instance, NumberOfBuffers, SamplesPerBuffer * MaxChannels * sizeof(short))
{
looped = instance.IsLooping;
this.channels = channels;
this.maxCompressedSize = maxCompressedSize;
this.fileProvider = fileProvider;
this.soundStreamUrl = soundStreamUrl;
this.sampleRate = sampleRate;
this.numberOfPackets = numberOfPackets;
playRange = new PlayRange(TimeSpan.Zero, TimeSpan.Zero);
NewSources.Add(this);
}
public SettingUiAppService(IStringLocalizer <SettingUiResource> localizer,
IStringLocalizerFactory factory,
IVirtualFileProvider fileProvider,
IJsonSerializer jsonSerializer,
ISettingDefinitionManager settingDefinitionManager,
ISettingManager settingManager,
IPermissionDefinitionManager permissionDefinitionManager)
{
_localizer = localizer;
_factory = factory;
_fileProvider = fileProvider;
_jsonSerializer = jsonSerializer;
_settingDefinitionManager = settingDefinitionManager;
_settingManager = settingManager;
_permissionDefinitionManager = permissionDefinitionManager;
}
/// <summary>
/// Unregisters the specified virtual file provider.
/// </summary>
/// <param name="provider">The provider.</param>
/// <param name="dispose">Indicate that the provider should be disposed, if it inherits from IDisposable interface.</param>
public static void UnregisterProvider(IVirtualFileProvider provider, bool dispose = true)
{
var mountPoints = providers.Where(x => x.Value == provider).ToArray();
foreach (var mountPoint in mountPoints)
{
providers.Remove(mountPoint.Key);
}
if (dispose)
{
var disposable = provider as IDisposable;
if (disposable != null)
{
disposable.Dispose();
}
}
}
/// <inheritdoc/>
public override void FileMove(string sourceUrl, IVirtualFileProvider destinationProvider, string destinationUrl)
{
var fsProvider = destinationProvider as FileSystemProvider;
if (fsProvider != null)
{
destinationProvider.CreateDirectory(destinationUrl.Substring(0, destinationUrl.LastIndexOf(VirtualFileSystem.DirectorySeparatorChar)));
File.Move(ConvertUrlToFullPath(sourceUrl), fsProvider.ConvertUrlToFullPath(destinationUrl));
}
else
{
using (Stream sourceStream = OpenStream(sourceUrl, VirtualFileMode.Open, VirtualFileAccess.Read),
destinationStream = destinationProvider.OpenStream(destinationUrl, VirtualFileMode.CreateNew, VirtualFileAccess.Write))
{
sourceStream.CopyTo(destinationStream);
}
FileDelete(sourceUrl);
}
}
//get shader source from data base, is there a more direct way?
public static string GetShaderSourceCode(string effectName, IVirtualFileProvider fileProvider, ShaderSourceManager shaderSourceManager)
{
var path = GetPathOfSdslShader(effectName, fileProvider);
if (!string.IsNullOrWhiteSpace(path))
{
try
{
return(File.ReadAllText(path));
}
catch (Exception)
{
//fall through
}
}
return(shaderSourceManager?.LoadShaderSource(effectName).Source);
}
public RedisRequiresLimitFeatureChecker(
ICurrentTenant currentTenant,
IVirtualFileProvider virtualFileProvider,
IOptions <AbpRedisRequiresLimitFeatureOptions> optionsAccessor)
{
if (optionsAccessor == null)
{
throw new ArgumentNullException(nameof(optionsAccessor));
}
_options = optionsAccessor.Value;
_currentTenant = currentTenant;
_virtualFileProvider = virtualFileProvider;
_instance = _options.InstanceName ?? string.Empty;
Logger = NullLogger <RedisRequiresLimitFeatureChecker> .Instance;
}
/// <inheritdoc/>
public override void FileMove(string sourceUrl, IVirtualFileProvider destinationProvider, string destinationUrl)
{
var fsProvider = destinationProvider as FileSystemProvider;
if (fsProvider != null)
{
destinationProvider.CreateDirectory(destinationUrl.Substring(0, destinationUrl.LastIndexOf(VirtualFileSystem.DirectorySeparatorChar)));
NativeFile.FileMove(ConvertUrlToFullPath(sourceUrl), fsProvider.ConvertUrlToFullPath(destinationUrl));
}
else
{
using (Stream sourceStream = OpenStream(sourceUrl, VirtualFileMode.Open, VirtualFileAccess.Read),
destinationStream = destinationProvider.OpenStream(destinationUrl, VirtualFileMode.CreateNew, VirtualFileAccess.Write))
{
sourceStream.CopyTo(destinationStream);
}
NativeFile.FileDelete(sourceUrl);
}
}
public GitHubSourceCodeStore(
IOptions <AbpCliOptions> options,
IJsonSerializer jsonSerializer,
ICancellationTokenProvider cancellationTokenProvider,
IVirtualFileProvider virtualFileProvider,
IOptions <OctokitOptions> octokitOptions,
IGitHubClient gitHubClient
)
{
JsonSerializer = jsonSerializer;
CancellationTokenProvider = cancellationTokenProvider;
Options = options.Value;
VirtualFileProvider = virtualFileProvider;
Logger = NullLogger <GitHubSourceCodeStore> .Instance;
OctokitOptions = octokitOptions.Value;
GitHubClient = gitHubClient;
}
/// <summary>
/// Initializes a new instance of the <see cref="VirtualFileSystem" /> class.
/// </summary>
static VirtualFileSystem()
{
PlatformFolders.IsVirtualFileSystemInitialized = true;
// TODO: find a better solution to customize the ApplicationDataDirectory, now we're very limited due to the initialization from a static constructor
#if SILICONSTUDIO_PLATFORM_ANDROID
ApplicationData = new ZipFileSystemProvider("/data", PlatformAndroid.Context.ApplicationInfo.SourceDir);
#else
ApplicationData = new FileSystemProvider("/data", Path.Combine(PlatformFolders.ApplicationDataDirectory, PlatformFolders.ApplicationDataSubDirectory));
#endif
ApplicationCache = new FileSystemProvider("/cache", PlatformFolders.ApplicationCacheDirectory);
#if SILICONSTUDIO_PLATFORM_IOS
// On iOS, we don't want cache folder to be cleared by the OS.
((FileSystemProvider)ApplicationCache).AutoSetSkipBackupAttribute = true;
#endif
ApplicationRoaming = new FileSystemProvider("/roaming", PlatformFolders.ApplicationRoamingDirectory);
ApplicationLocal = new FileSystemProvider("/local", PlatformFolders.ApplicationLocalDirectory);
ApplicationTemporary = new FileSystemProvider("/tmp", PlatformFolders.ApplicationTemporaryDirectory);
ApplicationBinary = new FileSystemProvider("/binary", PlatformFolders.ApplicationBinaryDirectory);
Drive = new DriveFileProvider(DriveFileProvider.DefaultRootPath);
}
/// <summary>
/// Initializes a new instance of the <see cref="VirtualFileSystem" /> class.
/// </summary>
static VirtualFileSystem()
{
PlatformFolders.IsVirtualFileSystemInitialized = true;
// TODO: find a better solution to customize the ApplicationDataDirectory, now we're very limited due to the initialization from a static constructor
#if SILICONSTUDIO_PLATFORM_ANDROID
ApplicationData = new ZipFileSystemProvider("/data", PlatformAndroid.Context.ApplicationInfo.SourceDir);
#else
ApplicationData = new FileSystemProvider("/data", Path.Combine(PlatformFolders.ApplicationDataDirectory, PlatformFolders.ApplicationDataSubDirectory));
#endif
ApplicationCache = new FileSystemProvider("/cache", PlatformFolders.ApplicationCacheDirectory);
#if SILICONSTUDIO_PLATFORM_IOS
// On iOS, we don't want cache folder to be cleared by the OS.
((FileSystemProvider)ApplicationCache).AutoSetSkipBackupAttribute = true;
#endif
ApplicationRoaming = new FileSystemProvider("/roaming", PlatformFolders.ApplicationRoamingDirectory);
ApplicationLocal = new FileSystemProvider("/local", PlatformFolders.ApplicationLocalDirectory);
ApplicationTemporary = new FileSystemProvider("/tmp", PlatformFolders.ApplicationTemporaryDirectory);
ApplicationBinary = new FileSystemProvider("/binary", PlatformFolders.ApplicationBinaryDirectory);
Drive = new DriveFileProvider(DriveFileProvider.DefaultRootPath);
}
/// <summary>
/// Add a new file provider
/// </summary>
/// <param name="fileProvider"> </param>
public void Add(IVirtualFileProvider fileProvider)
{
if (fileProvider == null) throw new ArgumentNullException("fileProvider");
_fileProviders.Add(fileProvider);
}
/// <summary>
/// Registers the specified virtual file provider at the specified mount location.
/// </summary>
/// <param name="provider">The provider.</param>
public static void RegisterProvider(IVirtualFileProvider provider)
{
if (provider.RootPath != null)
{
if (providers.ContainsKey(provider.RootPath))
throw new InvalidOperationException(string.Format("A Virtual File Provider with the root path \"{0}\" already exists.", provider.RootPath));
providers.Add(provider.RootPath, provider);
}
}
/// <inheritdoc/>
public virtual void FileMove(string sourceUrl, IVirtualFileProvider destinationProvider, string destinationUrl)
{
throw new NotImplementedException();
}
/// <summary>
/// Initializes a new instance of the <see cref="ShaderSourceManager" /> class.
/// </summary>
/// <param name="fileProvider">The file provider to use for loading shader sources.</param>
public ShaderSourceManager(IVirtualFileProvider fileProvider)
{
this.fileProvider = fileProvider;
LookupDirectoryList = new List<string>();
UrlToFilePath = new Dictionary<string, string>();
}
/// <summary>
/// Unregisters the specified virtual file provider.
/// </summary>
/// <param name="provider">The provider.</param>
/// <param name="dispose">Indicate that the provider should be disposed, if it inherits from IDisposable interface.</param>
public static void UnregisterProvider(IVirtualFileProvider provider, bool dispose = true)
{
var mountPoints = providers.Where(x => x.Value == provider).ToArray();
foreach (var mountPoint in mountPoints)
providers.Remove(mountPoint.Key);
}
/// <summary>
/// Opens the stream from a given path.
/// </summary>
/// <param name="path">The path.</param>
/// <param name="mode">The stream opening mode (append, open, create, etc...).</param>
/// <param name="access">The stream access.</param>
/// <param name="share">The stream share mode.</param>
/// <param name="provider">The provider used to load the stream.</param>
/// <returns>The stream.</returns>
public static Stream OpenStream(string path, VirtualFileMode mode, VirtualFileAccess access, VirtualFileShare share, out IVirtualFileProvider provider)
{
var resolveProviderResult = ResolveProvider(path, false);
provider = resolveProviderResult.Provider;
return provider.OpenStream(resolveProviderResult.Path, mode, access, share);
}
