JsonCodec.cs

using System;
using System.Collections;
using System.Collections.Generic;
using System.Text;
using System.Threading.Tasks;
using Waher.Runtime.Inventory;
using Waher.Runtime.IO;
using Waher.Script.Abstraction.Elements;
 
namespace Waher.Content.Json
{
    public class JsonCodec : IContentDecoder, IContentEncoder
    {
        public const string DefaultContentType = "application/json";
 
        public const string JsonRpcContentType = "application/json-rpc";
 
        public const string DefaultFileExtension = "json";
 
        public JsonCodec()
        {
        }
 
        public static readonly string[] JsonContentTypes = new string[]
        {
            DefaultContentType,
            JsonRpcContentType,
            "application/jsonrequest",
            "text/x-json"
        };
 
        public static readonly string[] JsonFileExtensions = new string[]
        {
            DefaultFileExtension
        };
 
        public string[] ContentTypes => JsonContentTypes;
 
        public string[] FileExtensions => JsonFileExtensions;
 
        public bool Decodes(string ContentType, out Grade Grade)
        {
            if (Array.IndexOf(JsonContentTypes, ContentType) >= 0)
            {
                Grade = Grade.Excellent;
                return true;
            }
            else if (ContentType.StartsWith("application/") && ContentType.EndsWith("+json"))
            {
                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);
            return Task.FromResult(new ContentResponse(ContentType, JSON.Parse(s), Data));
        }
 
        public bool TryGetContentType(string FileExtension, out string ContentType)
        {
            if (string.Compare(FileExtension, DefaultFileExtension, true) == 0)
            {
                ContentType = DefaultContentType;
                return true;
            }
            else
            {
                ContentType = null;
                return false;
            }
        }
 
        public bool TryGetFileExtension(string ContentType, out string FileExtension)
        {
            ContentType = ContentType.ToLower();
 
            if (Array.IndexOf(JsonContentTypes, ContentType) >= 0)
            {
                FileExtension = DefaultFileExtension;
                return true;
            }
            else if (ContentType.StartsWith("application/") && ContentType.EndsWith("+json"))
            {
                FileExtension = ContentType.Substring(12, ContentType.Length - 5 - 12);
                return true;
            }
            else
            {
                FileExtension = string.Empty;
                return false;
            }
        }
 
        public bool Encodes(object Object, out Grade Grade, params string[] AcceptedContentTypes)
        {
            if (InternetContent.IsAccepted(JsonContentTypes, AcceptedContentTypes))
            {
                if (Object is IEnumerable<KeyValuePair<string, object>>)
                {
                    Grade = Grade.Ok;
                    return true;
                }
                else if (Object is IJsonEncodingHint Hint)
                {
                    Grade = Hint.CanEncodeJson;
                    return Grade != Grade.NotAtAll;
                }
                else if (Object is null ||
                    Object is IEnumerable ||
                    Object is IVector ||
                    Object is string ||
                    Object is bool ||
                    Object is decimal ||
                    Object is double ||
                    Object is float ||
                    Object is int ||
                    Object is long ||
                    Object is short ||
                    Object is byte ||
                    Object is uint ||
                    Object is ulong ||
                    Object is ushort ||
                    Object is sbyte ||
                    Object is char)
                {
                    Grade = Grade.Barely;
                    return true;
                }
            }
 
            Grade = Grade.NotAtAll;
            return false;
        }
 
        public Task<ContentResponse> EncodeAsync(object Object, Encoding Encoding,
            ICodecProgress Progress, params string[] AcceptedContentTypes)
        {
            string Json = JSON.Encode(Object, false);
 
            if (!InternetContent.IsAccepted(JsonContentTypes, out string ContentType,
                AcceptedContentTypes))
            {
                ContentType = DefaultContentType;
            }
 
            if (Encoding is null)
            {
                Encoding = Encoding.UTF8;
                ContentType += "; charset=utf-8";
            }
            else
                ContentType += "; charset=" + Encoding.WebName;
 
            return Task.FromResult(new ContentResponse(ContentType, Object, Encoding.GetBytes(Json)));
        }
    }
}