wininet: Added Esperanto language.
[wine] / dlls / msi / order.c
1 /*
2  * Implementation of the Microsoft Installer (msi.dll)
3  *
4  * Copyright 2002 Mike McCormack for CodeWeavers
5  *
6  * This library is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (at your option) any later version.
10  *
11  * This library is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with this library; if not, write to the Free Software
18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
19  */
20
21 #include <stdarg.h>
22
23 #include "windef.h"
24 #include "winbase.h"
25 #include "winerror.h"
26 #include "wine/debug.h"
27 #include "msi.h"
28 #include "msiquery.h"
29 #include "objbase.h"
30 #include "objidl.h"
31 #include "msipriv.h"
32 #include "winnls.h"
33
34 #include "query.h"
35
36 WINE_DEFAULT_DEBUG_CHANNEL(msidb);
37
38
39 /* below is the query interface to a table */
40
41 typedef struct tagMSIORDERVIEW
42 {
43     MSIVIEW        view;
44     MSIDATABASE   *db;
45     MSIVIEW       *table;
46     UINT          *reorder;
47     UINT           num_cols;
48     UINT           cols[1];
49 } MSIORDERVIEW;
50
51 static UINT ORDER_compare( MSIORDERVIEW *ov, UINT a, UINT b, UINT *swap )
52 {
53     UINT r, i, a_val = 0, b_val = 0;
54
55     *swap = 0;
56     for( i=0; i<ov->num_cols; i++ )
57     {
58         r = ov->table->ops->fetch_int( ov->table, a, ov->cols[i], &a_val );
59         if( r != ERROR_SUCCESS )
60             return r;
61
62         r = ov->table->ops->fetch_int( ov->table, b, ov->cols[i], &b_val );
63         if( r != ERROR_SUCCESS )
64             return r;
65
66         if( a_val != b_val )
67         {
68             if( a_val > b_val )
69                 *swap = 1;
70             break;
71         }
72     }
73
74     return ERROR_SUCCESS;
75 }
76
77 static UINT ORDER_mergesort( MSIORDERVIEW *ov, UINT left, UINT right )
78 {
79     UINT r, centre = (left + right)/2, temp, swap = 0, i, j;
80     UINT *array = ov->reorder;
81
82     if( left == right )
83         return ERROR_SUCCESS;
84
85     /* sort the left half */
86     r = ORDER_mergesort( ov, left, centre );
87     if( r != ERROR_SUCCESS )
88         return r;
89
90     /* sort the right half */
91     r = ORDER_mergesort( ov, centre+1, right );
92     if( r != ERROR_SUCCESS )
93         return r;
94
95     for( i=left, j=centre+1; (i<=centre) && (j<=right); i++ )
96     {
97         r = ORDER_compare( ov, array[i], array[j], &swap );
98         if( r != ERROR_SUCCESS )
99             return r;
100         if( swap )
101         { 
102             temp = array[j];
103             memmove( &array[i+1], &array[i], (j-i)*sizeof (UINT) );
104             array[i] = temp;
105             j++;
106             centre++;
107         }
108     }
109
110     return ERROR_SUCCESS;
111 }
112
113 static UINT ORDER_verify( MSIORDERVIEW *ov, UINT num_rows )
114 {
115     UINT i, swap, r;
116
117     for( i=1; i<num_rows; i++ )
118     {
119         r = ORDER_compare( ov, ov->reorder[i-1], ov->reorder[i], &swap );
120         if( r != ERROR_SUCCESS )
121             return r;
122         if( !swap )
123             continue;
124         ERR("Bad order! %d\n", i);
125         return ERROR_FUNCTION_FAILED;
126     }
127
128     return ERROR_SUCCESS;
129 }
130
131 static UINT ORDER_fetch_int( struct tagMSIVIEW *view, UINT row, UINT col, UINT *val )
132 {
133     MSIORDERVIEW *ov = (MSIORDERVIEW*)view;
134
135     TRACE("%p %d %d %p\n", ov, row, col, val );
136
137     if( !ov->table )
138          return ERROR_FUNCTION_FAILED;
139
140     row = ov->reorder[ row ];
141
142     return ov->table->ops->fetch_int( ov->table, row, col, val );
143 }
144
145 static UINT ORDER_execute( struct tagMSIVIEW *view, MSIRECORD *record )
146 {
147     MSIORDERVIEW *ov = (MSIORDERVIEW*)view;
148     UINT r, num_rows = 0, i;
149
150     TRACE("%p %p\n", ov, record);
151
152     if( !ov->table )
153          return ERROR_FUNCTION_FAILED;
154
155     r = ov->table->ops->execute( ov->table, record );
156     if( r != ERROR_SUCCESS )
157         return r;
158
159     r = ov->table->ops->get_dimensions( ov->table, &num_rows, NULL );
160     if( r != ERROR_SUCCESS )
161         return r;
162
163     ov->reorder = msi_alloc( num_rows*sizeof(UINT) );
164     if( !ov->reorder )
165         return ERROR_FUNCTION_FAILED;
166
167     for( i=0; i<num_rows; i++ )
168         ov->reorder[i] = i;
169
170     r = ORDER_mergesort( ov, 0, num_rows - 1 );
171     if( r != ERROR_SUCCESS )
172         return r;
173
174     r = ORDER_verify( ov, num_rows );
175     if( r != ERROR_SUCCESS )
176         return r;
177
178     return ERROR_SUCCESS;
179 }
180
181 static UINT ORDER_close( struct tagMSIVIEW *view )
182 {
183     MSIORDERVIEW *ov = (MSIORDERVIEW*)view;
184
185     TRACE("%p\n", ov );
186
187     if( !ov->table )
188          return ERROR_FUNCTION_FAILED;
189
190     msi_free( ov->reorder );
191     ov->reorder = NULL;
192
193     return ov->table->ops->close( ov->table );
194 }
195
196 static UINT ORDER_get_dimensions( struct tagMSIVIEW *view, UINT *rows, UINT *cols )
197 {
198     MSIORDERVIEW *ov = (MSIORDERVIEW*)view;
199
200     TRACE("%p %p %p\n", ov, rows, cols );
201
202     if( !ov->table )
203          return ERROR_FUNCTION_FAILED;
204
205     return ov->table->ops->get_dimensions( ov->table, rows, cols );
206 }
207
208 static UINT ORDER_get_column_info( struct tagMSIVIEW *view,
209                 UINT n, LPWSTR *name, UINT *type )
210 {
211     MSIORDERVIEW *ov = (MSIORDERVIEW*)view;
212
213     TRACE("%p %d %p %p\n", ov, n, name, type );
214
215     if( !ov->table )
216          return ERROR_FUNCTION_FAILED;
217
218     return ov->table->ops->get_column_info( ov->table, n, name, type );
219 }
220
221 static UINT ORDER_modify( struct tagMSIVIEW *view, MSIMODIFY eModifyMode,
222                 MSIRECORD *rec )
223 {
224     MSIORDERVIEW *ov = (MSIORDERVIEW*)view;
225
226     TRACE("%p %d %p\n", ov, eModifyMode, rec );
227
228     if( !ov->table )
229          return ERROR_FUNCTION_FAILED;
230
231     return ov->table->ops->modify( ov->table, eModifyMode, rec );
232 }
233
234 static UINT ORDER_delete( struct tagMSIVIEW *view )
235 {
236     MSIORDERVIEW *ov = (MSIORDERVIEW*)view;
237
238     TRACE("%p\n", ov );
239
240     if( ov->table )
241         ov->table->ops->delete( ov->table );
242
243     msi_free( ov->reorder );
244     ov->reorder = NULL;
245
246     msiobj_release( &ov->db->hdr );
247     msi_free( ov );
248
249     return ERROR_SUCCESS;
250 }
251
252 static UINT ORDER_find_matching_rows( struct tagMSIVIEW *view, UINT col,
253     UINT val, UINT *row, MSIITERHANDLE *handle )
254 {
255     MSIORDERVIEW *ov = (MSIORDERVIEW*)view;
256     UINT r;
257
258     TRACE("%p, %d, %u, %p\n", ov, col, val, *handle);
259
260     if( !ov->table )
261          return ERROR_FUNCTION_FAILED;
262
263     r = ov->table->ops->find_matching_rows( ov->table, col, val, row, handle );
264
265     *row = ov->reorder[ *row ];
266
267     return r;
268 }
269
270
271 MSIVIEWOPS order_ops =
272 {
273     ORDER_fetch_int,
274     NULL,
275     NULL,
276     NULL,
277     ORDER_execute,
278     ORDER_close,
279     ORDER_get_dimensions,
280     ORDER_get_column_info,
281     ORDER_modify,
282     ORDER_delete,
283     ORDER_find_matching_rows
284 };
285
286 static UINT ORDER_AddColumn( MSIORDERVIEW *ov, LPCWSTR name )
287 {
288     UINT n, count, r;
289     MSIVIEW *table;
290
291     TRACE("%p adding %s\n", ov, debugstr_w( name ) );
292
293     if( ov->view.ops != &order_ops )
294         return ERROR_FUNCTION_FAILED;
295
296     table = ov->table;
297     if( !table )
298         return ERROR_FUNCTION_FAILED;
299     if( !table->ops->get_dimensions )
300         return ERROR_FUNCTION_FAILED;
301     if( !table->ops->get_column_info )
302         return ERROR_FUNCTION_FAILED;
303
304     r = table->ops->get_dimensions( table, NULL, &count );
305     if( r != ERROR_SUCCESS )
306         return r;
307
308     if( ov->num_cols >= count )
309         return ERROR_FUNCTION_FAILED;
310
311     r = VIEW_find_column( table, name, &n );
312     if( r != ERROR_SUCCESS )
313         return r;
314
315     ov->cols[ov->num_cols] = n;
316     TRACE("Ordering by column %s (%d)\n", debugstr_w( name ), n);
317
318     ov->num_cols++;
319
320     return ERROR_SUCCESS;
321 }
322
323 UINT ORDER_CreateView( MSIDATABASE *db, MSIVIEW **view, MSIVIEW *table,
324                        column_info *columns )
325 {
326     MSIORDERVIEW *ov = NULL;
327     UINT count = 0, r;
328     column_info *x;
329
330     TRACE("%p\n", ov );
331
332     r = table->ops->get_dimensions( table, NULL, &count );
333     if( r != ERROR_SUCCESS )
334     {
335         ERR("can't get table dimensions\n");
336         return r;
337     }
338
339     ov = msi_alloc_zero( sizeof *ov + sizeof (UINT) * count );
340     if( !ov )
341         return ERROR_FUNCTION_FAILED;
342     
343     /* fill the structure */
344     ov->view.ops = &order_ops;
345     msiobj_addref( &db->hdr );
346     ov->db = db;
347     ov->table = table;
348     ov->reorder = NULL;
349     ov->num_cols = 0;
350     *view = (MSIVIEW*) ov;
351
352     for( x = columns; x ; x = x->next )
353         ORDER_AddColumn( ov, x->column );
354
355     return ERROR_SUCCESS;
356 }