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<object> GetAsync(Uri Uri, X509Certificate Certificate,
            RemoteCertificateEventHandler RemoteCertificateValidator, params KeyValuePair<string, string>[] Headers)
        {
            return this.GetAsync(Uri, Certificate, RemoteCertificateValidator, 60000, Headers);
        }
 
        public Task<object> GetAsync(Uri Uri, X509Certificate Certificate, RemoteCertificateEventHandler RemoteCertificateValidator, 
            int TimeoutMs, params KeyValuePair<string, string>[] Headers)
        {
            KeyValuePair<byte[], string> P = Decode(Uri);
            return InternetContent.DecodeAsync(P.Value, P.Key, Uri);
        }
 
        public static KeyValuePair<byte[], string> Decode(Uri Uri)
        {
            string s = Uri.OriginalString;
            int i = s.IndexOf(':');
            if (i < 0)
                throw new ArgumentException("Invalid Data URI.", nameof(Uri));
 
            int j = s.IndexOf(';', i + 1);
            if (j < 0)
                throw 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)
                throw new ArgumentException("Data not encoded in Data URI.", nameof(Uri));
 
            byte[] Bin = Convert.FromBase64String(s.Substring(k + 1));
 
            return new KeyValuePair<byte[], string>(Bin, ContentType);
        }
 
        public Task<KeyValuePair<string, TemporaryStream>> GetTempStreamAsync(Uri Uri, X509Certificate Certificate,
            RemoteCertificateEventHandler RemoteCertificateValidator, params KeyValuePair<string, string>[] Headers)
        {
            return this.GetTempStreamAsync(Uri, Certificate, RemoteCertificateValidator, 60000, Headers);
        }
 
        public async Task<KeyValuePair<string, TemporaryStream>> GetTempStreamAsync(Uri Uri, X509Certificate Certificate,
            RemoteCertificateEventHandler RemoteCertificateValidator, int TimeoutMs, params KeyValuePair<string, string>[] Headers)
        {
            KeyValuePair<byte[], string> P = Decode(Uri);
            TemporaryStream f = new TemporaryStream();
            await f.WriteAsync(P.Key, 0, P.Key.Length);
 
            return new KeyValuePair<string, TemporaryStream>(P.Value, f);
        }
 
        public bool CanHead(Uri Uri, out Grade Grade)
        {
            Grade = Grade.NotAtAll;
            return false;
        }
 
        public Task<object> HeadAsync(Uri Uri, X509Certificate Certificate, RemoteCertificateEventHandler RemoteCertificateValidator, 
            params KeyValuePair<string, string>[] Headers)
        {
            return Task.FromResult<object>(null);
        }
 
        public Task<object> HeadAsync(Uri Uri, X509Certificate Certificate, RemoteCertificateEventHandler RemoteCertificateValidator, 
            int TimeoutMs, params KeyValuePair<string, string>[] Headers)
        {
            return Task.FromResult<object>(null);
        }
 
    }
}