← Back to branch summary

~ubuntu-branches/ubuntu/lucid/beagle/lucid

« back to all changes in this revision

Viewing changes to beagled/Mono.Data.SqliteClient/SqliteParameterCollection.cs

  • Committer: Bazaar Package Importer
  • Author(s): Emilio Pozuelo Monfort
  • Date: 2007-12-24 17:25:05 UTC
  • mfrom: (1.1.18 upstream)
  • Revision ID: james.westby@ubuntu.com-20071224172505-a5wsz6kdesm45vre
Tags: 0.3.1-2ubuntu1
* Merge from Debian unstable, remaining Ubuntu changes:
  - debian/control:
    + Rename iceweasel-beagle and icedove-beagle to mozilla-beagle and
      thunderbird-beagle, change the Recommends to Depends and update
      them accordingly.
    + Suggest schedutils for beagle.
    + Change Maintainer to Ubuntu Mono Team.
  - debian/rules:
    + Install the mozilla-beagle and thunderbird-beagle extensions.
  - ice{dove,weasel}.dirs:
    + Renamed to {mozilla,thunderbird}-beagle.dirs.
    + Fixed paths to point to usr/lib/{firefox,thunderbird}

Show diffs side-by-side

added added

removed removed

Lines of Context:
beagled/Mono.Data.SqliteClient/SqliteParameterCollection.cs
1
 
//
2
 
// Mono.Data.SqliteClient.SqliteParameterCollection.cs
3
 
//
4
 
// Represents a collection of parameters relevant to a SqliteCommand as well as 
5
 
// their respective mappings to columns in a DataSet.
6
 
//
7
 
//Author(s):            Vladimir Vukicevic  <vladimir@pobox.com>
8
 
//                      Everaldo Canuto  <everaldo_canuto@yahoo.com.br>
9
 
//                      Chris Turchin <chris@turchin.net>
10
 
//                      Jeroen Zwartepoorte <jeroen@xs4all.nl>
11
 
//                      Thomas Zoechling <thomas.zoechling@gmx.at>
12
 
//
13
 
// Copyright (C) 2002  Vladimir Vukicevic
14
 
//
15
 
// Permission is hereby granted, free of charge, to any person obtaining
16
 
// a copy of this software and associated documentation files (the
17
 
// "Software"), to deal in the Software without restriction, including
18
 
// without limitation the rights to use, copy, modify, merge, publish,
19
 
// distribute, sublicense, and/or sell copies of the Software, and to
20
 
// permit persons to whom the Software is furnished to do so, subject to
21
 
// the following conditions:
22
 
// 
23
 
// The above copyright notice and this permission notice shall be
24
 
// included in all copies or substantial portions of the Software.
25
 
// 
26
 
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
27
 
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
28
 
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
29
 
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
30
 
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
31
 
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
32
 
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
33
 
//
34
 
 
35
 
using System;
36
 
using System.Data;
37
 
using System.Collections;
38
 
 
39
 
namespace Mono.Data.SqliteClient
40
 
{
41
 
        public class SqliteParameterCollection : IDataParameterCollection, IList
42
 
        {
43
 
        
44
 
                #region Fields
45
 
                
46
 
                ArrayList numeric_param_list = new ArrayList();
47
 
                Hashtable named_param_hash = new Hashtable();
48
 
                
49
 
                #endregion
50
 
 
51
 
                #region Private Methods
52
 
 
53
 
                private void CheckSqliteParam (object value)
54
 
                {
55
 
                        if (!(value is SqliteParameter))
56
 
                                throw new InvalidCastException ("Can only use SqliteParameter objects");
57
 
                        SqliteParameter sqlp = value as SqliteParameter;
58
 
                        if (sqlp.ParameterName == null || sqlp.ParameterName.Length == 0)
59
 
                                sqlp.ParameterName = this.GenerateParameterName();
60
 
                 }
61
 
 
62
 
                private void RecreateNamedHash ()
63
 
                {
64
 
                        for (int i = 0; i < numeric_param_list.Count; i++) 
65
 
                        {
66
 
                                named_param_hash[((SqliteParameter) numeric_param_list[i]).ParameterName] = i;
67
 
                        }
68
 
                }
69
 
 
70
 
                //FIXME: if the user is calling Insert at various locations with unnamed parameters, this is not going to work....
71
 
                private string GenerateParameterName()
72
 
                {
73
 
                        int             index   = this.Count + 1;
74
 
                        string  name    = String.Empty;
75
 
 
76
 
                        while (index > 0)
77
 
                        {
78
 
                                name = ":" + index.ToString();
79
 
                                        if (this.IndexOf(name) == -1)
80
 
                                        index = -1;
81
 
                                else
82
 
                                index++;
83
 
                        }
84
 
                        return name;
85
 
                }
86
 
 
87
 
                #endregion
88
 
 
89
 
                #region Properties
90
 
                
91
 
                object IList.this[int index] {
92
 
                        get 
93
 
                        {
94
 
                                return this[index];
95
 
                        }
96
 
                        set 
97
 
                        {
98
 
                                CheckSqliteParam (value);
99
 
                                this[index] = (SqliteParameter) value;
100
 
                        }
101
 
                }
102
 
                
103
 
                object IDataParameterCollection.this[string parameterName] {
104
 
                        get 
105
 
                        {
106
 
                                return this[parameterName];
107
 
                        }
108
 
                        set 
109
 
                        {
110
 
                                CheckSqliteParam (value);
111
 
                                this[parameterName] = (SqliteParameter) value;
112
 
                        }
113
 
                }
114
 
                
115
 
                private bool isPrefixed (string parameterName)
116
 
                {
117
 
                        return parameterName.Length > 1 && (parameterName[0] == ':' || parameterName[0] == '$');
118
 
                }
119
 
                
120
 
                public SqliteParameter this[string parameterName] 
121
 
                {
122
 
                        get 
123
 
                        {
124
 
                                if (this.Contains(parameterName))
125
 
                                        return this[(int) named_param_hash[parameterName]];
126
 
                                else if (isPrefixed(parameterName) && this.Contains(parameterName.Substring(1)))
127
 
                                        return this[(int) named_param_hash[parameterName.Substring(1)]];
128
 
                                else
129
 
                                        throw new IndexOutOfRangeException("The specified name does not exist: " + parameterName);
130
 
                        }
131
 
                        set
132
 
                        {
133
 
                                if (this.Contains(parameterName))
134
 
                                        numeric_param_list[(int) named_param_hash[parameterName]] = value;
135
 
                                else if (parameterName.Length > 1 && this.Contains(parameterName.Substring(1)))
136
 
                                        numeric_param_list[(int) named_param_hash[parameterName.Substring(1)]] = value;
137
 
                                else
138
 
                                        throw new IndexOutOfRangeException("The specified name does not exist: " + parameterName);
139
 
                        }
140
 
                }
141
 
 
142
 
                public SqliteParameter this[int parameterIndex]
143
 
                {
144
 
                        get
145
 
                        {
146
 
                                if (this.Count >= parameterIndex+1)
147
 
                                        return (SqliteParameter) numeric_param_list[parameterIndex];
148
 
                                else          
149
 
                                        throw new IndexOutOfRangeException("The specified parameter index does not exist: " + parameterIndex.ToString());
150
 
                        }
151
 
                        set
152
 
                        {
153
 
                                if (this.Count >= parameterIndex+1)
154
 
                                        numeric_param_list[parameterIndex] = value;
155
 
                                else          
156
 
                                        throw new IndexOutOfRangeException("The specified parameter index does not exist: " + parameterIndex.ToString());
157
 
                        }
158
 
                }
159
 
 
160
 
 
161
 
                public int Count 
162
 
                {
163
 
                        get
164
 
                        {
165
 
                                return this.numeric_param_list.Count;
166
 
                        }
167
 
                }
168
 
 
169
 
                bool IList.IsFixedSize
170
 
                {
171
 
                        get
172
 
                        {
173
 
                                return this.numeric_param_list.IsFixedSize;
174
 
                        }
175
 
                }
176
 
 
177
 
                bool IList.IsReadOnly
178
 
                {
179
 
                        get
180
 
                        {
181
 
                                return this.numeric_param_list.IsReadOnly;
182
 
                        }
183
 
                }
184
 
 
185
 
 
186
 
                bool ICollection.IsSynchronized 
187
 
                {
188
 
                        get
189
 
                        {
190
 
                                return this.numeric_param_list.IsSynchronized;
191
 
                        }
192
 
                }
193
 
                
194
 
 
195
 
                object ICollection.SyncRoot 
196
 
                {
197
 
                        get
198
 
                        {
199
 
                                return this.numeric_param_list.SyncRoot;
200
 
                        }
201
 
                }
202
 
 
203
 
                #endregion
204
 
 
205
 
                #region Public Methods
206
 
                
207
 
                public int Add (object value)
208
 
                {
209
 
                        CheckSqliteParam (value);
210
 
                        SqliteParameter sqlp = value as SqliteParameter;
211
 
                        if (named_param_hash.Contains (sqlp.ParameterName))
212
 
                                throw new DuplicateNameException ("Parameter collection already contains the a SqliteParameter with the given ParameterName.");
213
 
                        named_param_hash[sqlp.ParameterName] = numeric_param_list.Add(value);
214
 
                                return (int) named_param_hash[sqlp.ParameterName];
215
 
                }
216
 
 
217
 
                public SqliteParameter Add (SqliteParameter param)
218
 
                {
219
 
                        Add ((object)param);
220
 
                        return param;
221
 
                }
222
 
                
223
 
                public SqliteParameter Add (string name, object value)
224
 
                {
225
 
                        return Add (new SqliteParameter (name, value));
226
 
                }
227
 
                
228
 
                public SqliteParameter Add (string name, DbType type)
229
 
                {
230
 
                        return Add (new SqliteParameter (name, type));
231
 
                }
232
 
                
233
 
                public void Clear ()
234
 
                {
235
 
                        numeric_param_list.Clear ();
236
 
                        named_param_hash.Clear ();
237
 
                }
238
 
                
239
 
                public void CopyTo (Array array, int index)
240
 
                {
241
 
                        this.numeric_param_list.CopyTo(array, index);
242
 
                }
243
 
                
244
 
                bool IList.Contains (object value)
245
 
                {
246
 
                        return Contains ((SqliteParameter) value);
247
 
                }
248
 
                
249
 
                public bool Contains (string parameterName)
250
 
                {
251
 
                        return named_param_hash.Contains (parameterName);
252
 
                }
253
 
                
254
 
                public bool Contains (SqliteParameter param)
255
 
                {
256
 
                        return Contains (param.ParameterName);
257
 
                }
258
 
                
259
 
                public IEnumerator GetEnumerator ()
260
 
                {
261
 
                        return this.numeric_param_list.GetEnumerator();
262
 
                }
263
 
                
264
 
                int IList.IndexOf (object param)
265
 
                {
266
 
                        return IndexOf ((SqliteParameter) param);
267
 
                }
268
 
                
269
 
                public int IndexOf (string parameterName)
270
 
                {
271
 
                        if (named_param_hash.Contains(parameterName))
272
 
                                return (int) named_param_hash[parameterName];
273
 
                        else
274
 
                                return -1;
275
 
                }
276
 
                
277
 
                public int IndexOf (SqliteParameter param)
278
 
                {
279
 
                        return IndexOf (param.ParameterName);
280
 
                }
281
 
                
282
 
                public void Insert (int index, object value)
283
 
                {
284
 
                        CheckSqliteParam (value);
285
 
                        if (numeric_param_list.Count == index) 
286
 
                        {
287
 
                                Add (value);
288
 
                                return;
289
 
                        }
290
 
                        
291
 
                        numeric_param_list.Insert (index, value);
292
 
                        RecreateNamedHash ();
293
 
                }
294
 
                
295
 
                public void Remove (object value)
296
 
                {
297
 
                        CheckSqliteParam (value);
298
 
                        RemoveAt ((SqliteParameter) value);
299
 
                }
300
 
                
301
 
                public void RemoveAt (int index)
302
 
                {
303
 
                        RemoveAt (((SqliteParameter) numeric_param_list[index]).ParameterName);
304
 
                }
305
 
                
306
 
                public void RemoveAt (string parameterName)
307
 
                {
308
 
                        if (!named_param_hash.Contains (parameterName))
309
 
                                throw new ApplicationException ("Parameter " + parameterName + " not found");
310
 
                        
311
 
                        numeric_param_list.RemoveAt ((int) named_param_hash[parameterName]);
312
 
                        named_param_hash.Remove (parameterName);
313
 
                        
314
 
                        RecreateNamedHash ();
315
 
                }
316
 
                
317
 
                public void RemoveAt (SqliteParameter param)
318
 
                {
319
 
                        RemoveAt (param.ParameterName);
320
 
                }
321
 
                
322
 
                #endregion
323
 
        }
324
 
}