BinaryCodec.cs

using System;
using System.Collections.Generic;
using System.Text;
using System.Threading.Tasks;
using Waher.Runtime.Inventory;
 
namespace Waher.Content.Binary
{
    public class BinaryCodec : IContentDecoder, IContentEncoder
    {
        public BinaryCodec()
        {
        }
 
        public const string DefaultContentType = "application/octet-stream";
 
        public static readonly string[] BinaryContentTypes = new string[]
        {
            DefaultContentType,
            "binary"
        };
 
        public static readonly string[] BinaryFileExtensions = new string[]
        {
            "bin"
        };
 
        public string[] ContentTypes => BinaryContentTypes;
 
        public string[] FileExtensions => BinaryFileExtensions;
 
        public bool Decodes(string ContentType, out Grade Grade)
        {
            if (Array.IndexOf(BinaryContentTypes, ContentType) >= 0)
            {
                Grade = Grade.Ok;
                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>(Data);
        }
 
        public bool TryGetContentType(string FileExtension, out string ContentType)
        {
            if (string.Compare(FileExtension, "bin", true) == 0)
            {
                ContentType = DefaultContentType;
                return true;
            }
            else
            {
                ContentType = string.Empty;
                return false;
            }
        }
 
        public bool TryGetFileExtension(string ContentType, out string FileExtension)
        {
            switch (ContentType.ToLower())
            {
                case DefaultContentType:
                case "binary":
                    FileExtension = "bin";
                    return true;
 
                default:
                    FileExtension = string.Empty;
                    return false;
            }
        }
 
        public bool Encodes(object Object, out Grade Grade, params string[] AcceptedContentTypes)
        {
            if (InternetContent.IsAccepted(BinaryContentTypes, AcceptedContentTypes) &&
                (Object is byte[]))
            {
                Grade = Grade.Ok;
                return true;
            }
            else if (Object is EncodedObject Obj && InternetContent.IsAccepted(new string[] { Obj.ContentType }, AcceptedContentTypes))
            {
                Grade = Grade.Ok;
                return true;
            }
            else
            {
                Grade = Grade.NotAtAll;
                return false;
            }
        }
 
        public Task<KeyValuePair<byte[], string>> EncodeAsync(object Object, Encoding Encoding, params string[] AcceptedContentTypes)
        {
            if (Object is byte[] Bin)
                return Task.FromResult(new KeyValuePair<byte[], string>(Bin, DefaultContentType));
            else if (Object is EncodedObject Obj)
                return Task.FromResult(new KeyValuePair<byte[], string>(Obj.Data, Obj.ContentType));
            else
                throw new ArgumentException("Unable to encode as binary.", nameof(Object));
        }
    }
}