ServiceStack/src/ServiceStack.Client/PclExportClient.NetStandard.cs at master · zigmo/ServiceStack · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
//Copyright (c) ServiceStack, Inc. All Rights Reserved.
//License: https://raw.github.com/ServiceStack/ServiceStack/master/license.txt

#if NETSTANDARD1_1 || NETSTANDARD1_6
using System;
using System.Collections.Specialized;
using System.IO;
using System.Linq;
using System.Net;
using System.Threading;
using ServiceStack;
using ServiceStack.Web;
using ServiceStack.Pcl;
using System.Collections.Generic;


namespace ServiceStack
{
    public class NetStandardPclExportClient : PclExportClient
    {
        public static NetStandardPclExportClient Provider = new NetStandardPclExportClient();

        static readonly Dictionary<string, bool> multiHeaders = new Dictionary<string, bool> (StringComparer.OrdinalIgnoreCase) {
                {HttpHeaders.Allow,              false},
                {HttpHeaders.Accept,             false},
                {HttpHeaders.Authorization,      false},
                {HttpHeaders.AcceptRanges,       false},
                {HttpHeaders.AcceptCharset,      false},
                {HttpHeaders.AcceptEncoding,     false},
                {HttpHeaders.AcceptLanguage,     false},
                {HttpHeaders.Cookie,             false},
                {HttpHeaders.Connection,         false},
                {HttpHeaders.CacheControl,       false},
                {HttpHeaders.ContentEncoding,    false},
                {HttpHeaders.ContentLanguage,    false},
                {HttpHeaders.Expect,             false},
                {HttpHeaders.IfMatch,            false},
                {HttpHeaders.IfNoneMatch,        false},
                {HttpHeaders.Pragma,             false},
                {HttpHeaders.ProxyAuthenticate,  false},
                {HttpHeaders.ProxyAuthorization, false},
                {HttpHeaders.ProxyConnection,    false},
                {HttpHeaders.Range,              false},
                {HttpHeaders.SetCookie,          false},
                {HttpHeaders.SetCookie2,         false},
                {HttpHeaders.TE,                 false},
                {HttpHeaders.Trailer,            false},
                {HttpHeaders.TransferEncoding,   false},
                {HttpHeaders.Upgrade,            false},
                {HttpHeaders.Via,                false},
                {HttpHeaders.Vary,               false},
                {HttpHeaders.Warning,            false}
            };

        public static PclExportClient Configure()
        {
            Configure(Provider ?? (Provider = new NetStandardPclExportClient()));
            NetStandardPclExport.Configure();
            return Provider;
        }

        public override INameValueCollection NewNameValueCollection()
        {
            return new NameValueCollectionWrapper(new NameValueCollection());
        }

        public override string GetHeader(WebHeaderCollection headers, string name, Func<string, bool> valuePredicate)
        {
            var values = GetValues(headers, name);
            return values?.FirstOrDefault(valuePredicate);
        }

        //see .NET 4.6.2 Reference source
        private static string[] GetValues(WebHeaderCollection headers, string header)
        {
            var value = headers[header];

            if (value == null)
                return null;

            if (!multiHeaders.ContainsKey(header))
                return new string[1]{value};

            var tempStringCollection = new List<string>();

            bool inquote = false;
            int chIndex = 0;
            char[] vp = new char[value.Length];
            string singleValue;

            for (int i = 0; i < value.Length; i++)
            {
                if (value[i] == '\"')
                {
                    inquote = !inquote;
                }
                else if ((value[i] == ',') && !inquote)
                {
                    singleValue = new string(vp, 0, chIndex);
                    tempStringCollection.Add(singleValue.Trim());
                    chIndex = 0;
                    continue;
                }
                vp[chIndex++] = value[i];
            }

            if (chIndex != 0)
            {
                singleValue = new string(vp, 0, chIndex);
                tempStringCollection.Add(singleValue.Trim());
            }

            return tempStringCollection.ToArray();
        }
    }

#if !NETSTANDARD1_1
    public class AsyncTimer : ITimer
    {
        public System.Threading.Timer Timer;

        public AsyncTimer(System.Threading.Timer timer)
        {
            Timer = timer;
        }

        public void Cancel()
        {
            if (Timer == null) return;

            this.Timer.Change(Timeout.Infinite, Timeout.Infinite);
            this.Dispose();
        }

        public void Dispose()
        {
            if (Timer == null) return;

            this.Timer.Dispose();
            this.Timer = null;
        }
    }
#endif
}
#endif