SparqlQueryCodec.cs

using System;
using System.Collections.Generic;
using System.Text;
using System.Threading.Tasks;
using Waher.Content;
using Waher.Runtime.Inventory;
 
namespace Waher.Script.Persistence.SPARQL
{
    public class SparqlQueryCodec : IContentDecoder, IContentEncoder
    {
        public SparqlQueryCodec()
        {
        }
 
        public string[] ContentTypes => SparqlQueryContentTypes;
 
        private static readonly string[] SparqlQueryContentTypes = new string[]
        {
            "application/sparql-query"
        };
 
        public string[] FileExtensions => SparqlQueryFileExtensions;
 
        private static readonly string[] SparqlQueryFileExtensions = new string[]
        {
            "rq"
        };
 
        public bool Decodes(string ContentType, out Grade Grade)
        {
            if (Array.IndexOf(SparqlQueryContentTypes, ContentType) >= 0)
            {
                Grade = Grade.Excellent;
                return true;
            }
            else
            {
                Grade = Grade.NotAtAll;
                return false;
            }
        }
 
        public Task<object> DecodeAsync(string ContentType, byte[] Data, Encoding Encoding, KeyValuePair<string, string>[] Fields, Uri BaseUri)
        {
            string s = CommonTypes.GetString(Data, Encoding ?? Encoding.UTF8);
            Expression Exp = new Expression(s, BaseUri?.AbsolutePath);
 
            if (!(Exp.Root is SparqlQuery Query))
                throw new Exception("Invalid SPARQL query.");
 
            return Task.FromResult<object>(Query);
        }
 
        public bool Encodes(object Object, out Grade Grade, params string[] AcceptedContentTypes)
        {
            if (Object is SparqlQuery &&
                InternetContent.IsAccepted(SparqlQueryContentTypes, AcceptedContentTypes))
            {
                Grade = Grade.Excellent;
                return true;
            }
            else if (Object is Expression Exp && 
                Exp.Root is SparqlQuery &&
                InternetContent.IsAccepted(SparqlQueryContentTypes, AcceptedContentTypes))
            {
                Grade = Grade.Excellent;
                return true;
            }
            else
            {
                Grade = Grade.NotAtAll;
                return false;
            }
        }
 
        public Task<KeyValuePair<byte[], string>> EncodeAsync(object Object, Encoding Encoding, params string[] AcceptedContentTypes)
        {
            if (Encoding is null)
                Encoding = Encoding.UTF8;
 
            if (!(Object is SparqlQuery Query))
            {
                if (Object is Expression Exp && Exp.Root is SparqlQuery Query2)
                    Query = Query2;
                else
                    throw new ArgumentException("Unable to encode object.", nameof(Object));
            }
 
            string Text = JSON.Encode(Query.SubExpression, false);
            byte[] Bin = Encoding.GetBytes(Text);
            string ContentType = SparqlQueryContentTypes[0] + "; charset=" + Encoding.WebName;
 
            return Task.FromResult(new KeyValuePair<byte[], string>(Bin, ContentType));
        }
 
        public bool TryGetContentType(string FileExtension, out string ContentType)
        {
            if (string.Compare(FileExtension, SparqlQueryFileExtensions[0], true) == 0)
            {
                ContentType = SparqlQueryContentTypes[0];
                return true;
            }
            else
            {
                ContentType = null;
                return false;
            }
        }
 
        public bool TryGetFileExtension(string ContentType, out string FileExtension)
        {
            if (Array.IndexOf(SparqlQueryContentTypes, ContentType) >= 0)
            {
                FileExtension = SparqlQueryFileExtensions[0];
                return true;
            }
            else
            {
                FileExtension = null;
                return false;
            }
        }
    }
}