TurtleCodec.cs

using System;
using System.Collections.Generic;
using System.Text;
using System.Threading.Tasks;
using Waher.Content.Text;
using Waher.Runtime.Inventory;
using Waher.Runtime.IO;
 
namespace Waher.Content.Semantic
{
    public class TurtleCodec : IContentDecoder, IContentEncoder
    {
        public TurtleCodec()
        {
        }
 
        public string[] ContentTypes => TurtleContentTypes;
 
        public static readonly string[] TurtleContentTypes = new string[]
        {
            DefaultContentType,
            "application/x-turtle"
        };
 
        public string[] FileExtensions => TurtleFileExtensions;
 
        private static readonly string[] TurtleFileExtensions = new string[]
        {
            DefaultExtension
        };
 
        public const string DefaultContentType = "text/turtle";
 
        public const string DefaultExtension = "ttl";
 
        public bool Decodes(string ContentType, out Grade Grade)
        {
            if (Array.IndexOf(TurtleContentTypes, ContentType) >= 0)
            {
                Grade = Grade.Ok;
                return true;
            }
            else
            {
                Grade = Grade.NotAtAll;
                return false;
            }
        }
 
        public Task<ContentResponse> DecodeAsync(string ContentType, byte[] Data, Encoding Encoding,
            KeyValuePair<string, string>[] Fields, Uri BaseUri, ICodecProgress Progress)
        {
            string s = Strings.GetString(Data, Encoding ?? Encoding.UTF8);
            TurtleDocument Parsed = new TurtleDocument(s, BaseUri, "n", BlankNodeIdMode.Guid);
            return Task.FromResult(new ContentResponse(ContentType, Parsed, Data));
        }
 
        public bool Encodes(object Object, out Grade Grade, params string[] AcceptedContentTypes)
        {
            if (Object is TurtleDocument &&
                InternetContent.IsAccepted(TurtleContentTypes, AcceptedContentTypes))
            {
                Grade = Grade.Excellent;
                return true;
            }
            else if (Object is ISemanticModel)
            {
                if (InternetContent.IsAccepted(TurtleContentTypes, AcceptedContentTypes))
                {
                    Grade = Grade.Ok;
                    return true;
                }
                else if (InternetContent.IsAccepted(PlainTextCodec.DefaultContentType, AcceptedContentTypes))
                {
                    Grade = Grade.Barely;
                    return true;
                }
            }
 
            Grade = Grade.NotAtAll;
            return false;
        }
 
        public Task<ContentResponse> EncodeAsync(object Object, Encoding Encoding, ICodecProgress Progress, params string[] AcceptedContentTypes)
        {
            if (Encoding is null)
                Encoding = Encoding.UTF8;
 
            string Text;
 
            if (Object is TurtleDocument Doc)
                Text = Doc.Text;
            else
            {
                if (!(Object is ISemanticModel Model))
                    return Task.FromResult(new ContentResponse(new ArgumentException("Unable to encode object.", nameof(Object))));
 
                StringBuilder sb = new StringBuilder();
 
                foreach (ISemanticTriple Triple in Model)
                {
                    sb.Append(Triple.Subject);
                    sb.Append('\t');
                    sb.Append(Triple.Predicate);
                    sb.Append('\t');
                    sb.Append(Triple.Object);
                    sb.Append('\t');
                    sb.AppendLine(".");
                }
 
                Text = sb.ToString();
            }
 
            byte[] Bin = Encoding.GetBytes(Text);
            string ContentType = TurtleContentTypes[0] + "; charset=" + Encoding.WebName;
 
            return Task.FromResult(new ContentResponse(ContentType, Object, Bin));
        }
 
        public bool TryGetContentType(string FileExtension, out string ContentType)
        {
            if (string.Compare(FileExtension, TurtleFileExtensions[0], true) == 0)
            {
                ContentType = TurtleContentTypes[0];
                return true;
            }
            else
            {
                ContentType = null;
                return false;
            }
        }
 
        public bool TryGetFileExtension(string ContentType, out string FileExtension)
        {
            if (Array.IndexOf(TurtleContentTypes, ContentType) >= 0)
            {
                FileExtension = TurtleFileExtensions[0];
                return true;
            }
            else
            {
                FileExtension = null;
                return false;
            }
        }
    }
}