PlantUmlCodec.cs

using System;
using System.Collections.Generic;
using System.Text;
using System.Threading.Tasks;
using Waher.Runtime.Inventory;
using Waher.Runtime.IO;
 
namespace Waher.Content.Markdown.PlantUml
{
    public class PlantUmlCodec : IContentDecoder, IContentEncoder
    {
        public PlantUmlCodec()
        {
        }
 
        public const string DefaultContentType = "text/vnd.plantuml";
 
        public static readonly string[] PlantUmlContentTypes = new string[]
        {
            DefaultContentType
        };
 
        public static readonly string[] PlantUmlFileExtensions = new string[]
        {
            "uml"
        };
 
        public string[] ContentTypes => PlantUmlContentTypes;
 
        public string[] FileExtensions => PlantUmlFileExtensions;
 
        public bool Decodes(string ContentType, out Grade Grade)
        {
            if (Array.IndexOf(PlantUmlContentTypes, ContentType) >= 0)
            {
                Grade = Grade.Barely;
                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 PlantUml = Strings.GetString(Data, Encoding);
            return Task.FromResult(new ContentResponse(ContentType, new PlantUmlDocument(PlantUml), Data));
        }
 
        public bool TryGetContentType(string FileExtension, out string ContentType)
        {
            switch (FileExtension.ToLower())
            {
                case "uml":
                    ContentType = PlantUmlContentTypes[0];
                    return true;
 
                default:
                    ContentType = string.Empty;
                    return false;
            }
        }
 
        public bool TryGetFileExtension(string ContentType, out string FileExtension)
        {
            switch (ContentType.ToLower())
            {
                case DefaultContentType:
                    FileExtension = PlantUmlFileExtensions[0];
                    return true;
 
                default:
                    FileExtension = string.Empty;
                    return false;
            }
        }
 
        public bool Encodes(object Object, out Grade Grade, params string[] AcceptedContentTypes)
        {
            if (Object is PlantUmlDocument)
            {
                if (InternetContent.IsAccepted(PlantUmlContentTypes, 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 (!InternetContent.IsAccepted(PlantUmlContentTypes, out string ContentType, AcceptedContentTypes))
                return Task.FromResult(new ContentResponse(new ArgumentException("Unable to encode object, or content type not accepted.", nameof(Object))));
 
            string s;
 
            if (Object is PlantUmlDocument PlantUmlDoc)
                s = PlantUmlDoc.GraphDescription;
            else
                s = Object.ToString();
 
            if (Encoding is null)
            {
                ContentType += "; charset=utf-8";
                Encoding = Encoding.UTF8;
            }
            else
                ContentType += "; charset=" + Encoding.WebName;
 
            return Task.FromResult(new ContentResponse(ContentType, Object, Encoding.GetBytes(s)));
        }
    }
}