gui: Fix behavior of print preview in psppire-output-window.
[pspp] / src / data / case-map.c
1 /* PSPP - a program for statistical analysis.
2    Copyright (C) 1997-9, 2000, 2006, 2007, 2009, 2011 Free Software Foundation, Inc.
3
4    This program is free software: you can redistribute it and/or modify
5    it under the terms of the GNU General Public License as published by
6    the Free Software Foundation, either version 3 of the License, or
7    (at your option) any later version.
8
9    This program is distributed in the hope that it will be useful,
10    but WITHOUT ANY WARRANTY; without even the implied warranty of
11    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12    GNU General Public License for more details.
13
14    You should have received a copy of the GNU General Public License
15    along with this program.  If not, see <http://www.gnu.org/licenses/>. */
16
17 #include <config.h>
18
19 #include "data/case-map.h"
20
21 #include <stdio.h>
22 #include <stdlib.h>
23
24 #include "data/casereader.h"
25 #include "data/casewriter.h"
26 #include "data/dictionary.h"
27 #include "data/variable.h"
28 #include "data/case.h"
29 #include "libpspp/assertion.h"
30
31 #include "gl/xalloc.h"
32
33 /* A case map. */
34 struct case_map
35   {
36     struct caseproto *proto;   /* Prototype for output cases. */
37     int *map;                  /* For each destination index, the
38                                   corresponding source index. */
39   };
40
41 static struct ccase *translate_case (struct ccase *, void *map_);
42 static bool destroy_case_map (void *map_);
43
44 /* Creates and returns an empty map that outputs cases matching
45    PROTO. */
46 static struct case_map *
47 create_case_map (const struct caseproto *proto)
48 {
49   size_t n_values = caseproto_get_n_widths (proto);
50   struct case_map *map;
51   size_t i;
52
53   map = xmalloc (sizeof *map);
54   map->proto = caseproto_ref (proto);
55   map->map = xnmalloc (n_values, sizeof *map->map);
56   for (i = 0; i < n_values; i++)
57     map->map[i] = -1;
58
59   return map;
60 }
61
62 /* Inserts into MAP a mapping of the value at index FROM in the
63    source case to the value at index TO in the destination
64    case. */
65 static void
66 insert_mapping (struct case_map *map, size_t from, size_t to)
67 {
68   assert (to < caseproto_get_n_widths (map->proto));
69   assert (map->map[to] == -1);
70   map->map[to] = from;
71 }
72
73 /* Destroys case map MAP. */
74 void
75 case_map_destroy (struct case_map *map)
76 {
77   if (map != NULL)
78     {
79       caseproto_unref (map->proto);
80       free (map->map);
81       free (map);
82     }
83 }
84
85 /* If MAP is nonnull, returns a new case that is the result of
86    applying case map MAP to SRC, and unrefs SRC.
87
88    If MAP is null, returns SRC unchanged. */
89 struct ccase *
90 case_map_execute (const struct case_map *map, struct ccase *src)
91 {
92   if (map != NULL)
93     {
94       size_t n_values = caseproto_get_n_widths (map->proto);
95       struct ccase *dst;
96       size_t dst_idx;
97
98       dst = case_create (map->proto);
99       for (dst_idx = 0; dst_idx < n_values; dst_idx++)
100         {
101           int src_idx = map->map[dst_idx];
102           if (src_idx != -1)
103             value_copy (case_data_rw_idx (dst, dst_idx), case_data_idx (src, src_idx), caseproto_get_width (map->proto, dst_idx));
104         }
105       case_unref (src);
106       return dst;
107     }
108   else
109     return src;
110 }
111
112 /* Returns the prototype for output cases created by MAP.  The
113    caller must not unref the returned case prototype. */
114 const struct caseproto *
115 case_map_get_proto (const struct case_map *map)
116 {
117   return map->proto;
118 }
119
120 /* Creates and returns a new casereader whose cases are produced
121    by reading from SUBREADER and executing the actions of MAP.  
122    The casereader will have as many `union value's as MAP.  When
123    the new casereader is destroyed, MAP will be destroyed too.
124
125    After this function is called, SUBREADER must not ever again
126    be referenced directly.  It will be destroyed automatically
127    when the returned casereader is destroyed. */
128 struct casereader *
129 case_map_create_input_translator (struct case_map *map,
130                                   struct casereader *subreader) 
131 {
132     return casereader_create_translator (subreader,
133                                          case_map_get_proto (map),
134                                          translate_case,
135                                          destroy_case_map,
136                                          map);
137 }
138
139 /* Creates and returns a new casewriter.  Cases written to the
140    new casewriter will be passed through MAP and written to
141    SUBWRITER.  The casewriter will have as many `union value's as
142    MAP.  When the new casewriter is destroyed, MAP will be
143    destroyed too.
144
145    After this function is called, SUBWRITER must not ever again
146    be referenced directly.  It will be destroyed automatically
147    when the returned casewriter is destroyed. */
148 struct casewriter *
149 case_map_create_output_translator (struct case_map *map,
150                                    struct casewriter *subwriter) 
151 {
152     return casewriter_create_translator (subwriter,
153                                          case_map_get_proto (map),
154                                          translate_case,
155                                          destroy_case_map,
156                                          map);
157 }
158
159 /* Casereader/casewriter translation callback. */
160 static struct ccase *
161 translate_case (struct ccase *input, void *map_)
162 {
163   struct case_map *map = map_;
164   return case_map_execute (map, input);
165 }
166
167 /* Casereader/casewriter destruction callback. */
168 static bool
169 destroy_case_map (void *map_)
170 {
171   struct case_map *map = map_;
172   case_map_destroy (map);
173   return true;
174 }
175
176 /* Creates and returns a case_map that can be used to compact
177    cases for dictionary D.
178
179    Compacting a case eliminates "holes" between values and after
180    the last value.  (Holes are created by deleting variables.)
181
182    All variables are compacted if EXCLUDE_CLASSES is 0, or it may
183    contain one or more of (1u << DC_ORDINARY), (1u << DC_SYSTEM),
184    or (1u << DC_SCRATCH) to cause the corresponding type of
185    variable to be deleted during compaction. */
186 struct case_map *
187 case_map_to_compact_dict (const struct dictionary *d,
188                           unsigned int exclude_classes)
189 {
190   size_t n_vars = dict_get_var_cnt (d);
191   struct caseproto *proto;
192   struct case_map *map;
193   size_t n_values;
194   size_t i;
195
196   /* Create the case mapping. */
197   proto = dict_get_compacted_proto (d, exclude_classes);
198   map = create_case_map (proto);
199   caseproto_unref (proto);
200
201   /* Add the values to the case mapping. */
202   n_values = 0;
203   for (i = 0; i < n_vars; i++)
204     {
205       struct variable *v = dict_get_var (d, i);
206       if (!(exclude_classes & (1u << var_get_dict_class (v))))
207         insert_mapping (map, var_get_case_index (v), n_values++);
208     }
209
210   return map;
211 }
212
213 /* Prepares dictionary D for producing a case map.  Afterward,
214    the caller may delete, reorder, or rename variables within D
215    at will before using case_map_from_dict() to produce the case
216    map.
217
218    Uses D's aux members, which must otherwise not be in use. */
219 void
220 case_map_prepare_dict (const struct dictionary *d)
221 {
222   size_t var_cnt = dict_get_var_cnt (d);
223   size_t i;
224
225   for (i = 0; i < var_cnt; i++)
226     {
227       struct variable *v = dict_get_var (d, i);
228       int *src_fv = xmalloc (sizeof *src_fv);
229       *src_fv = var_get_case_index (v);
230       var_attach_aux (v, src_fv, var_dtor_free);
231     }
232 }
233
234 /* Produces a case map from dictionary D, which must have been
235    previously prepared with case_map_prepare_dict().
236
237    Does not retain any reference to D, and clears the aux members
238    set up by case_map_prepare_dict().
239
240    Returns the new case map, or a null pointer if no mapping is
241    required (that is, no data has changed position). */
242 struct case_map *
243 case_map_from_dict (const struct dictionary *d)
244 {
245   struct case_map *map;
246   size_t var_cnt = dict_get_var_cnt (d);
247   size_t n_values;
248   size_t i;
249   bool identity_map = true;
250
251   map = create_case_map (dict_get_proto (d));
252   for (i = 0; i < var_cnt; i++)
253     {
254       struct variable *v = dict_get_var (d, i);
255       int *src_fv = var_detach_aux (v);
256
257       if (var_get_case_index (v) != *src_fv)
258         identity_map = false;
259
260       insert_mapping (map, *src_fv, var_get_case_index (v));
261
262       free (src_fv);
263     }
264
265   if (identity_map)
266     {
267       case_map_destroy (map);
268       return NULL;
269     }
270
271   n_values = caseproto_get_n_widths (map->proto);
272   while (n_values > 0 && caseproto_get_width (map->proto, n_values - 1) == -1)
273     map->proto = caseproto_remove_widths (map->proto, --n_values, 1);
274
275   return map;
276 }
277
278 /* Creates and returns a case map for mapping variables in OLD to
279    variables in NEW based on their name.  For every variable in
280    NEW, there must be a variable in OLD with the same name, type,
281    and width. */
282 struct case_map *
283 case_map_by_name (const struct dictionary *old,
284                   const struct dictionary *new)
285 {
286   struct case_map *map;
287   size_t var_cnt = dict_get_var_cnt (new);
288   size_t i;
289
290   map = create_case_map (dict_get_proto (new));
291   for (i = 0; i < var_cnt; i++)
292     {
293       struct variable *nv = dict_get_var (new, i);
294       struct variable *ov = dict_lookup_var_assert (old, var_get_name (nv));
295       assert (var_get_width (nv) == var_get_width (ov));
296       insert_mapping (map, var_get_case_index (ov), var_get_case_index (nv));
297     }
298   return map;
299 }
300
301 /* Prints the mapping represented by case map CM to stdout, for
302    debugging purposes. */
303 void
304 case_map_dump (const struct case_map *cm)
305 {
306   int i;
307   for (i = 0 ; i < caseproto_get_n_widths (cm->proto); ++i )
308     printf ("%d -> %d\n", i, cm->map[i]);
309 }