DataGetter.cs

using System;
using System.Collections.Generic;
using System.Security.Cryptography.X509Certificates;
using System.Threading.Tasks;
using Waher.Runtime.Inventory;
using Waher.Runtime.Temporary;
 
namespace Waher.Content.Getters
{
    public class DataGetter : IContentGetter, IContentHeader
    {
        public DataGetter()
        {
        }
 
        public string[] UriSchemes => new string[] { "data" };
 
        public bool CanGet(Uri Uri, out Grade Grade)
        {
            switch (Uri.Scheme.ToLower())
            {
                case "data":
                    Grade = Grade.Ok;
                    return true;
 
                default:
                    Grade = Grade.NotAtAll;
                    return false;
            }
        }
 
        public Task<ContentResponse> GetAsync(Uri Uri, X509Certificate Certificate,
            EventHandler<RemoteCertificateEventArgs> RemoteCertificateValidator, params KeyValuePair<string, string>[] Headers)
        {
            return this.GetAsync(Uri, Certificate, RemoteCertificateValidator, InternetContent.DefaultTimeout, Headers);
        }
 
        public Task<ContentResponse> GetAsync(Uri Uri, X509Certificate Certificate, EventHandler<RemoteCertificateEventArgs> RemoteCertificateValidator, 
            int TimeoutMs, params KeyValuePair<string, string>[] Headers)
        {
            ContentBinaryResponse P = Decode(Uri);
            if (P.HasError)
                return Task.FromResult(new ContentResponse(P.Error));
            else
                return InternetContent.DecodeAsync(P.ContentType, P.Encoded, Uri);
        }
 
        public static ContentBinaryResponse Decode(Uri Uri)
        {
            string s = Uri.OriginalString;
            int i = s.IndexOf(':');
            if (i < 0)
                return new ContentBinaryResponse(new ArgumentException("Invalid Data URI.", nameof(Uri)));
 
            int j = s.IndexOf(';', i + 1);
            if (j < 0)
                return new ContentBinaryResponse(new ArgumentException("Content-Type not encoded in Data URI.", nameof(Uri)));
 
            string ContentType = s.Substring(i + 1, j - i - 1);
 
            int k = s.IndexOf(',', j + 1);
            if (k < 0)
                return new ContentBinaryResponse(new ArgumentException("Data not encoded in Data URI.", nameof(Uri)));
 
            byte[] Bin = Convert.FromBase64String(s.Substring(k + 1));
 
            return new ContentBinaryResponse(ContentType, Bin);
        }
 
        public Task<ContentStreamResponse> GetTempStreamAsync(Uri Uri, X509Certificate Certificate,
            EventHandler<RemoteCertificateEventArgs> RemoteCertificateValidator, params KeyValuePair<string, string>[] Headers)
        {
            return this.GetTempStreamAsync(Uri, Certificate, RemoteCertificateValidator, InternetContent.DefaultTimeout, Headers);
        }
 
        public Task<ContentStreamResponse> GetTempStreamAsync(Uri Uri, X509Certificate Certificate,
            EventHandler<RemoteCertificateEventArgs> RemoteCertificateValidator, TemporaryStream Destination, params KeyValuePair<string, string>[] Headers)
        {
            return this.GetTempStreamAsync(Uri, Certificate, RemoteCertificateValidator, InternetContent.DefaultTimeout, Destination, Headers);
        }
 
        public Task<ContentStreamResponse> GetTempStreamAsync(Uri Uri, X509Certificate Certificate,
            EventHandler<RemoteCertificateEventArgs> RemoteCertificateValidator, int TimeoutMs, params KeyValuePair<string, string>[] Headers)
        {
            return this.GetTempStreamAsync(Uri, Certificate, RemoteCertificateValidator, TimeoutMs, null, Headers);
        }
 
        public async Task<ContentStreamResponse> GetTempStreamAsync(Uri Uri, X509Certificate Certificate,
            EventHandler<RemoteCertificateEventArgs> RemoteCertificateValidator, int TimeoutMs, TemporaryStream Destination, 
            params KeyValuePair<string, string>[] Headers)
        {
            ContentBinaryResponse P = Decode(Uri);
            if (P.HasError)
                return new ContentStreamResponse(P.Error);
 
            if (Destination is null)
                Destination = new TemporaryStream();
 
            await Destination.WriteAsync(P.Encoded, 0, P.Encoded.Length);
 
            return new ContentStreamResponse(P.ContentType, Destination);
        }
 
        public bool CanHead(Uri Uri, out Grade Grade)
        {
            Grade = Grade.NotAtAll;
            return false;
        }
 
        public Task<ContentResponse> HeadAsync(Uri Uri, X509Certificate Certificate, EventHandler<RemoteCertificateEventArgs> RemoteCertificateValidator, 
            params KeyValuePair<string, string>[] Headers)
        {
            ContentBinaryResponse P = Decode(Uri);
            if (P.HasError)
                return Task.FromResult(new ContentResponse(P.Error));
            else
                return Task.FromResult(new ContentResponse(P.ContentType, null, null));
        }
 
        public Task<ContentResponse> HeadAsync(Uri Uri, X509Certificate Certificate, EventHandler<RemoteCertificateEventArgs> RemoteCertificateValidator, 
            int TimeoutMs, params KeyValuePair<string, string>[] Headers)
        {
            return this.HeadAsync(Uri, Certificate, RemoteCertificateValidator, Headers);
        }
 
    }
}