GraphStoreFileSource.cs

using System;
using System.IO;
using System.Threading.Tasks;
using Waher.Content;
using Waher.Content.Binary;
using Waher.Content.Semantic;
using Waher.Runtime.Inventory;
using Waher.Script.Model;
using Waher.Things;
 
namespace Waher.Script.Persistence.SPARQL.Sources
{
    public class GraphStoreFileSource : IGraphSource
    {
        private readonly GraphReference reference;
 
        public GraphStoreFileSource(GraphReference Reference)
        {
            this.reference = Reference;
        }
 
        public Grade Supports(Uri _)
        {
            return Grade.NotAtAll;  // Explicitly selected by processor.
        }
 
        public Task<ISemanticCube> LoadGraph(Uri Source, ScriptNode Node, bool NullIfNotFound,
            RequestOrigin Caller)
        {
            // TODO: Check access privileges
 
            return this.LoadGraph(Source, NullIfNotFound);
        }
 
        public async Task<ISemanticCube> LoadGraph(Uri Source, bool NullIfNotFound)
        { 
            string[] Files = Directory.GetFiles(this.reference.Folder, "*.*", SearchOption.TopDirectoryOnly);
            ISemanticCube Result = null;
            InMemorySemanticCube Union = null;
 
            foreach (string FileName in Files)
            {
                string Extension = Path.GetExtension(FileName);
                string ContentType = InternetContent.GetContentType(Extension);
                if (string.IsNullOrEmpty(ContentType) || ContentType == BinaryCodec.DefaultContentType)
                    continue;
 
                byte[] Bin = await Runtime.IO.Files.ReadAllBytesAsync(FileName);
                ContentResponse Content = await InternetContent.DecodeAsync(ContentType, Bin, Source);
                Content.AssertOk();
 
                if (Union is null && !(Result is null))
                {
                    Union = new InMemorySemanticCube();
                    await Union.Add(Result);
                }
 
                if (Union is null)
                {
                    Result = Content.Decoded as ISemanticCube;
                    if (Result is null)
                    {
                        if (Content.Decoded is ISemanticModel Model)
                            Result = await InMemorySemanticCube.Create(Model);
                        else
                            continue;
                    }
                }
                else
                {
                    if (Content.Decoded is ISemanticModel Model)
                        await Union.Add(Model);
                }
            }
 
            return Union ?? Result ?? (NullIfNotFound ? null : new InMemorySemanticCube());
        }
 
    }
}