Statistics
| Branch: | Revision:

root / trunk / hammock / src / net35 / Hammock / Web / WebPairCollection.cs @ 0eea575a

History | View | Annotate | Download (5.3 kB)

1
using System;
2
using System.Collections;
3
using System.Collections.Generic;
4
using System.Linq;
5

    
6
#if !SILVERLIGHT
7
using System.Collections.Specialized;
8
#else
9
using Hammock.Silverlight.Compat;
10
#endif
11

    
12
namespace Hammock.Web
13
{
14
    public class WebPairCollection : IList<WebPair>
15
    {
16
        private IList<WebPair> _parameters;
17

    
18
        public virtual WebPair this[string name]
19
        {
20
            get
21
            {
22
                var parameters = this.Where(p => p.Name.Equals(name));
23
                
24
                if(parameters.Count() == 0)
25
                {
26
                    return null;
27
                }
28

    
29
                if(parameters.Count() == 1)
30
                {
31
                    return parameters.Single();
32
                }
33

    
34
                var value = string.Join(",", parameters.Select(p => p.Value).ToArray());
35
                return new WebPair(name, value);
36
            }
37
        }
38

    
39
        public virtual IEnumerable<string> Names
40
        {
41
            get { return _parameters.Select(p => p.Name); }
42
        }
43

    
44
        public virtual IEnumerable<string> Values
45
        {
46
            get { return _parameters.Select(p => p.Value); }
47
        }
48

    
49
        public WebPairCollection(IEnumerable<WebPair> parameters)
50
        {
51
            _parameters = new List<WebPair>(parameters);
52
        }
53

    
54
        public WebPairCollection(NameValueCollection collection) : this()
55
        {
56
            AddCollection(collection);
57
        }
58

    
59
        public virtual void AddRange(NameValueCollection collection)
60
        {
61
            AddCollection(collection);
62
        }
63

    
64
        private void AddCollection(NameValueCollection collection)
65
        {
66
            var parameters = collection.AllKeys.Select(key => new WebPair(key, collection[key]));
67
            foreach (var parameter in parameters)
68
            {
69
                _parameters.Add(parameter);
70
            }
71
        }
72

    
73
        public WebPairCollection(IDictionary<string, string> collection) : this()
74
        {
75
            AddCollection(collection);
76
        }
77

    
78
        public void AddCollection(IDictionary<string, string> collection)
79
        {
80
            foreach (var parameter in collection.Keys.Select(key => new WebPair(key, collection[key])))
81
            {
82
                _parameters.Add(parameter);
83
            }
84
        }
85

    
86
        public WebPairCollection()
87
        {
88
            _parameters = new List<WebPair>(0);
89
        }
90

    
91
        public WebPairCollection(int capacity)
92
        {
93
            _parameters = new List<WebPair>(capacity);
94
        }
95

    
96
        private void AddCollection(IEnumerable<WebPair> collection)
97
        {
98
            foreach (var pair in collection.Select(parameter => new WebPair(parameter.Name, parameter.Value)))
99
            {
100
                _parameters.Add(pair);
101
            }
102
        }
103

    
104
        public virtual void AddRange(WebPairCollection collection)
105
        {
106
            AddCollection(collection);
107
        }
108

    
109
        public virtual void AddRange(IEnumerable<WebPair> collection)
110
        {
111
            AddCollection(collection);
112
        }
113

    
114
        public virtual void Sort(Comparison<WebPair> comparison)
115
        {
116
            var sorted = new List<WebPair>(_parameters);
117
            sorted.Sort(comparison);
118
            _parameters = sorted;
119
        }
120

    
121
        public virtual bool RemoveAll(IEnumerable<WebPair> parameters)
122
        {
123
            var array = parameters.ToArray();
124
            var success = array.Aggregate(true, (current, parameter) => current & _parameters.Remove(parameter));
125
            return success && array.Length > 0;
126
        }
127

    
128
        public virtual void Add(string name, string value)
129
        {
130
            var pair = new WebPair(name, value);
131
            _parameters.Add(pair);
132
        }
133

    
134
        #region IList<WebParameter> Members
135

    
136
        public virtual IEnumerator<WebPair> GetEnumerator()
137
        {
138
            return _parameters.GetEnumerator();
139
        }
140

    
141
        IEnumerator IEnumerable.GetEnumerator()
142
        {
143
            return GetEnumerator();
144
        }
145

    
146
        public virtual void Add(WebPair parameter)
147
        {
148
            
149
            _parameters.Add(parameter);
150
        }
151

    
152
        public virtual void Clear()
153
        {
154
            _parameters.Clear();
155
        }
156

    
157
        public virtual bool Contains(WebPair parameter)
158
        {
159
            return _parameters.Contains(parameter);
160
        }
161

    
162
        public virtual void CopyTo(WebPair[] parameters, int arrayIndex)
163
        {
164
            _parameters.CopyTo(parameters, arrayIndex);
165
        }
166

    
167
        public virtual bool Remove(WebPair parameter)
168
        {
169
            return _parameters.Remove(parameter);
170
        }
171

    
172
        public virtual int Count
173
        {
174
            get { return _parameters.Count; }
175
        }
176

    
177
        public virtual bool IsReadOnly
178
        {
179
            get { return _parameters.IsReadOnly; }
180
        }
181

    
182
        public virtual int IndexOf(WebPair parameter)
183
        {
184
            return _parameters.IndexOf(parameter);
185
        }
186

    
187
        public virtual void Insert(int index, WebPair parameter)
188
        {
189
            _parameters.Insert(index, parameter);
190
        }
191

    
192
        public virtual void RemoveAt(int index)
193
        {
194
            _parameters.RemoveAt(index);
195
        }
196

    
197
        public virtual WebPair this[int index]
198
        {
199
            get { return _parameters[index]; }
200
            set { _parameters[index] = value; }
201
        }
202

    
203
        #endregion
204
    }
205
}