PlainTextCodec.cs

using System;
using System.Collections.Generic;
using System.Text;
using System.Threading.Tasks;
using Waher.Runtime.Inventory;
 
namespace Waher.Content.Text
{
    public class PlainTextCodec : IContentDecoder, IContentEncoder
    {
        public PlainTextCodec()
        {
        }
 
        public const string DefaultContentType = "text/plain";
 
        public static readonly string[] PlainTextContentTypes = new string[]
        {
            DefaultContentType,
            "text/sgml",
            "text/richtext"
        };
 
        public static readonly string[] PlainTextFileExtensions = new string[]
        {
            "txt",
            "text",
            "sgml",
            "rtx",
            "log",
            "ini",
            "asc",
            "me",
            "readme",
            "1st",
            "license",
            "faq",
            "note",
            "utf8",
            "plain"
        };
 
        public string[] ContentTypes => PlainTextContentTypes;
 
        public string[] FileExtensions => PlainTextFileExtensions;
 
        public bool Decodes(string ContentType, out Grade Grade)
        {
            if (ContentType == DefaultContentType)
            {
                Grade = Grade.Excellent;
                return true;
            }
            else if (ContentType.StartsWith("text/"))
            {
                Grade = Grade.Barely;
                return true;
            }
            else
            {
                Grade = Grade.NotAtAll;
                return false;
            }
        }
 
        public Task<object> DecodeAsync(string ContentType, byte[] Data, Encoding Encoding, KeyValuePair<string, string>[] Fields, Uri BaseUri)
        {
            return Task.FromResult<object>(CommonTypes.GetString(Data, Encoding));
        }
 
        public bool TryGetContentType(string FileExtension, out string ContentType)
        {
            switch (FileExtension.ToLower())
            {
                case "txt":
                case "text":
                case "log":
                case "ini":
                case "asc":
                case "me":
                case "readme":
                case "1st":
                case "license":
                case "faq":
                case "note":
                case "utf8":
                case "plain":
                    ContentType = PlainTextCodec.DefaultContentType;
                    return true;
 
                case "sgml":
                    ContentType = "text/sgml";
                    return true;
 
                case "rtx":
                    ContentType = "text/richtext";
                    return true;
 
                default:
                    ContentType = string.Empty;
                    return false;
            }
        }
 
        public bool TryGetFileExtension(string ContentType, out string FileExtension)
        {
            switch (ContentType.ToLower())
            {
                case PlainTextCodec.DefaultContentType:
                    FileExtension = "txt";
                    return true;
 
                case "text/sgml":
                    FileExtension = "sgml";
                    return true;
 
                case "text/richtext":
                    FileExtension = "rtx";
                    return true;
 
                default:
                    FileExtension = string.Empty;
                    return false;
            }
        }
 
        public bool Encodes(object Object, out Grade Grade, params string[] AcceptedContentTypes)
        {
            if (Object is string)
            {
                if (InternetContent.IsAccepted(PlainTextCodec.DefaultContentType, AcceptedContentTypes))
                {
                    Grade = Grade.Ok;
                    return true;
                }
                else
                {
                    foreach (string s in AcceptedContentTypes)
                    {
                        if (s.StartsWith("text/"))
                        {
                            Grade = Grade.Barely;
                            return true;
                        }
                    }
                }
            }
 
            Grade = Grade.NotAtAll;
            return false;
        }
 
        public Task<KeyValuePair<byte[], string>> EncodeAsync(object Object, Encoding Encoding, params string[] AcceptedContentTypes)
        {
            string ContentType;
 
            if (Encoding is null)
            {
                ContentType = PlainTextCodec.DefaultContentType + "; charset=utf-8";
                Encoding = Encoding.UTF8;
            }
            else
                ContentType = PlainTextCodec.DefaultContentType + "; charset=" + Encoding.WebName;
 
            return Task.FromResult(new KeyValuePair<byte[], string>(Encoding.GetBytes(Object.ToString()), ContentType));
        }
    }
}