NullDatabaseProvider.cs

using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using System.Xml;
using Waher.Persistence.Filters;
using Waher.Persistence.Serialization;
using Waher.Runtime.Profiling;
 
namespace Waher.Persistence
{
    public class NullDatabaseProvider : IDatabaseProvider
    {
        public NullDatabaseProvider()
        {
        }
 
        public Task Insert(object Object) => Task.CompletedTask;
 
        public Task Insert(params object[] Objects) => Task.CompletedTask;
 
        public Task Insert(IEnumerable<object> Objects) => Task.CompletedTask;
 
        public Task InsertLazy(object Object, ObjectCallback Callback) => Task.CompletedTask;
 
        public Task InsertLazy(object[] Objects, ObjectsCallback Callback) => Task.CompletedTask;
 
        public Task InsertLazy(IEnumerable<object> Objects, ObjectsCallback Callback) => Task.CompletedTask;
 
        public Task<IEnumerable<T>> Find<T>(int Offset, int MaxCount, params string[] SortOrder)
            where T : class
        {
            return Task.FromResult<IEnumerable<T>>(Array.Empty<T>());
        }
 
        public Task<IEnumerable<T>> Find<T>(int Offset, int MaxCount, Filter Filter, params string[] SortOrder)
            where T : class
        {
            return Task.FromResult<IEnumerable<T>>(Array.Empty<T>());
        }
 
        public Task<IEnumerable<object>> Find(string Collection, int Offset, int MaxCount, params string[] SortOrder)
        {
            return Task.FromResult<IEnumerable<object>>(Array.Empty<object>());
        }
 
        public Task<IEnumerable<object>> Find(string Collection, int Offset, int MaxCount, Filter Filter, params string[] SortOrder)
        {
            return Task.FromResult<IEnumerable<object>>(Array.Empty<object>());
        }
 
        public Task<IEnumerable<T>> Find<T>(string Collection, int Offset, int MaxCount, Filter Filter, params string[] SortOrder)
            where T : class
        {
            return Task.FromResult<IEnumerable<T>>(Array.Empty<T>());
        }
 
        public Task<IPage<T>> FindFirst<T>(int PageSize, params string[] SortOrder)
            where T : class
        {
            return Task.FromResult<IPage<T>>(new EmptyPage<T>());
        }
 
        public Task<IPage<T>> FindFirst<T>(int PageSize, Filter Filter, params string[] SortOrder)
            where T : class
        {
            return Task.FromResult<IPage<T>>(new EmptyPage<T>());
        }
 
        public Task<IPage<object>> FindFirst(string Collection, int PageSize, params string[] SortOrder)
        {
            return Task.FromResult<IPage<object>>(new EmptyPage<object>());
        }
 
        public Task<IPage<object>> FindFirst(string Collection, int PageSize, Filter Filter, params string[] SortOrder)
        {
            return Task.FromResult<IPage<object>>(new EmptyPage<object>());
        }
 
        public Task<IPage<T>> FindFirst<T>(string Collection, int PageSize, Filter Filter, params string[] SortOrder)
            where T : class
        {
            return Task.FromResult<IPage<T>>(new EmptyPage<T>());
        }
 
        public Task<IPage<T>> FindNext<T>(IPage<T> Page)
            where T : class
        {
            return Task.FromResult<IPage<T>>(new EmptyPage<T>());
        }
 
        public Task<IPage<object>> FindNext(IPage<object> Page)
        {
            return Task.FromResult<IPage<object>>(new EmptyPage<object>());
        }
 
        public Task<bool> Process<T>(IProcessor<T> Processor, int Offset, int MaxCount, params string[] SortOrder)
            where T : class
        {
            return Task.FromResult(false);
        }
 
        public Task<bool> Process<T>(IProcessor<T> Processor, int Offset, int MaxCount,
            Filter Filter, params string[] SortOrder)
            where T : class
        {
            return Task.FromResult(false);
        }
 
        public Task<bool> Process(IProcessor<object> Processor, string Collection, int Offset, int MaxCount,
            params string[] SortOrder)
        {
            return Task.FromResult(false);
        }
 
        public Task<bool> Process(IProcessor<object> Processor, string Collection, int Offset, int MaxCount,
            Filter Filter, params string[] SortOrder)
        {
            return Task.FromResult(false);
        }
 
        public Task<bool> Process<T>(IProcessor<T> Processor, string Collection, int Offset, int MaxCount, Filter Filter, params string[] SortOrder)
            where T : class
        {
            return Task.FromResult(false);
        }
 
        public Task Update(object Object) => Task.CompletedTask;
 
        public Task Update(params object[] Objects) => Task.CompletedTask;
 
        public Task Update(IEnumerable<object> Objects) => Task.CompletedTask;
 
        public Task UpdateLazy(object Object, ObjectCallback Callback) => Task.CompletedTask;
 
        public Task UpdateLazy(object[] Objects, ObjectsCallback Callback) => Task.CompletedTask;
 
        public Task UpdateLazy(IEnumerable<object> Objects, ObjectsCallback Callback) => Task.CompletedTask;
 
        public Task Delete(object Object) => Task.CompletedTask;
 
        public Task Delete(params object[] Objects) => Task.CompletedTask;
 
        public Task Delete(IEnumerable<object> Objects) => Task.CompletedTask;
 
        public Task DeleteLazy(object Object, ObjectCallback Callback) => Task.CompletedTask;
 
        public Task DeleteLazy(object[] Objects, ObjectsCallback Callback) => Task.CompletedTask;
 
        public Task DeleteLazy(IEnumerable<object> Objects, ObjectsCallback Callback) => Task.CompletedTask;
 
        public Task<IEnumerable<T>> FindDelete<T>(int Offset, int MaxCount, params string[] SortOrder)
            where T : class
        {
            return Task.FromResult<IEnumerable<T>>(Array.Empty<T>());
        }
 
        public Task<IEnumerable<T>> FindDelete<T>(int Offset, int MaxCount, Filter Filter, params string[] SortOrder)
            where T : class
        {
            return Task.FromResult<IEnumerable<T>>(Array.Empty<T>());
        }
 
        public Task<IEnumerable<object>> FindDelete(string Collection, int Offset, int MaxCount, params string[] SortOrder)
        {
            return Task.FromResult<IEnumerable<object>>(Array.Empty<object>());
        }
 
        public Task<IEnumerable<object>> FindDelete(string Collection, int Offset, int MaxCount, Filter Filter, params string[] SortOrder)
        {
            return Task.FromResult<IEnumerable<object>>(Array.Empty<object>());
        }
 
        public Task DeleteLazy<T>(int Offset, int MaxCount, string[] SortOrder, ObjectsCallback Callback)
            where T : class => Task.CompletedTask;
 
        public Task DeleteLazy<T>(int Offset, int MaxCount, Filter Filter, string[] SortOrder, ObjectsCallback Callback)
            where T : class => Task.CompletedTask;
 
        public Task DeleteLazy(string Collection, int Offset, int MaxCount, string[] SortOrder, ObjectsCallback Callback) => Task.CompletedTask;
 
        public Task DeleteLazy(string Collection, int Offset, int MaxCount, Filter Filter, string[] SortOrder, ObjectsCallback Callback) => Task.CompletedTask;
 
        public Task<T> TryLoadObject<T>(object ObjectId)
            where T : class
        {
            return default;
        }
 
        public Task<T> TryLoadObject<T>(string CollectionName, object ObjectId)
            where T : class
        {
            return default;
        }
 
        public Task<object> TryLoadObject(string CollectionName, object ObjectId)
        {
            return null;
        }
 
        public Task<bool> Export(IDatabaseExport Output, string[] CollectionNames) => Task.FromResult(true);
 
        public Task<bool> Export(IDatabaseExport Output, string[] CollectionNames, ProfilerThread Thread) => Task.FromResult(true);
 
        public Task Iterate<T>(IDatabaseIteration<T> Recipient, string[] CollectionNames)
            where T : class
        {
            return Task.CompletedTask;
        }
 
        public Task Iterate<T>(IDatabaseIteration<T> Recipient, string[] CollectionNames, ProfilerThread Thread)
            where T : class
        {
            return Task.CompletedTask;
        }
 
        public Task Clear(string CollectionName) => Task.CompletedTask;
 
        public Task<string[]> Analyze(XmlWriter Output, string XsltPath, string ProgramDataFolder, bool ExportData)
        {
            return Task.FromResult(Array.Empty<string>());
        }
 
        public Task<string[]> Analyze(XmlWriter Output, string XsltPath, string ProgramDataFolder, bool ExportData, ProfilerThread Thread)
        {
            return Task.FromResult(Array.Empty<string>());
        }
 
        public Task<string[]> Repair(XmlWriter Output, string XsltPath, string ProgramDataFolder, bool ExportData)
        {
            return Task.FromResult(Array.Empty<string>());
        }
 
        public Task<string[]> Repair(XmlWriter Output, string XsltPath, string ProgramDataFolder, bool ExportData, ProfilerThread Thread)
        {
            return Task.FromResult(Array.Empty<string>());
        }
 
        public Task<string[]> Analyze(XmlWriter Output, string XsltPath, string ProgramDataFolder, bool ExportData, bool Repair)
        {
            return Task.FromResult(Array.Empty<string>());
        }
 
        public Task<string[]> Analyze(XmlWriter Output, string XsltPath, string ProgramDataFolder, bool ExportData, bool Repair, ProfilerThread Thread)
        {
            return Task.FromResult(Array.Empty<string>());
        }
 
        public Task<string[]> Repair(params string[] CollectionNames)
        {
            return Task.FromResult(Array.Empty<string>());
        }
 
        public Task<string[]> Repair(ProfilerThread Thread, params string[] CollectionNames)
        {
            return Task.FromResult(Array.Empty<string>());
        }
 
        public Task AddIndex(string CollectionName, string[] FieldNames) => Task.CompletedTask;
 
        public Task RemoveIndex(string CollectionName, string[] FieldNames) => Task.CompletedTask;
 
        public Task<string[][]> GetIndices(string CollectionName) => Task.FromResult(new string[0][]);
 
        public Task StartBulk() => Task.CompletedTask;
 
        public Task EndBulk() => Task.CompletedTask;
 
        public Task Start() => Task.CompletedTask;
 
        public Task Stop() => Task.CompletedTask;
 
        public Task Flush() => Task.CompletedTask;
 
        public int ObjectIdByteCount => 0;
 
        public Task<IPersistentDictionary> GetDictionary(string Collection) => throw new InvalidOperationException("Server is shutting down.");
 
        public Task<string[]> GetDictionaries() => Task.FromResult(Array.Empty<string>());
 
        public Task<IPersistedQueue> GetQueue(string QueueName, bool CanBeNull) => 
            throw new InvalidOperationException("Server is shutting down.");
 
        public Task<string[]> GetQueues() => Task.FromResult(Array.Empty<string>());
 
        public Task<string[]> GetCollections()
        {
            return Task.FromResult(Array.Empty<string>());
        }
 
        public Task<string> GetCollection(Type Type)
        {
            return Task.FromResult(string.Empty);
        }
 
        public Task<string> GetCollection(Object Object)
        {
            return Task.FromResult(string.Empty);
        }
 
        public Task<bool> IsLabel(string Collection, string Label)
        {
            return Task.FromResult(false);
        }
 
        public Task<string[]> GetLabels(string Collection)
        {
            return Task.FromResult(Array.Empty<string>());
        }
 
        public Task<object> TryGetObjectId(object Object)
        {
            return Task.FromResult<object>(null);
        }
 
        public Task DropCollection(string CollectionName) => Task.CompletedTask;
 
        public Task<GenericObject> Generalize(object Object) => Task.FromResult<GenericObject>(null);
 
        public Task<object> Specialize(GenericObject Object) => Task.FromResult<object>(null);
 
        public string[] GetExcludedCollections() => Array.Empty<string>();
    }
}