gui: Fix behavior of print preview in psppire-output-window.
[pspp] / src / data / casegrouper.c
1 /* PSPP - a program for statistical analysis.
2    Copyright (C) 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/casegrouper.h"
20
21 #include <stdlib.h>
22
23 #include "data/casereader.h"
24 #include "data/casewriter.h"
25 #include "data/dictionary.h"
26 #include "data/subcase.h"
27 #include "libpspp/taint.h"
28
29 #include "gl/xalloc.h"
30
31 /* A casegrouper. */
32 struct casegrouper
33   {
34     struct casereader *reader;  /* Source of input cases. */
35     struct taint *taint;        /* Error status for casegrouper. */
36
37     /* Functions for grouping cases. */
38     bool (*same_group) (const struct ccase *, const struct ccase *, void *aux);
39     void (*destroy) (void *aux);
40     void *aux;
41   };
42
43 /* Creates and returns a new casegrouper that takes its input
44    from READER.  SAME_GROUP is used to decide which cases are in
45    a group: it returns true if the pair of cases provided are in
46    the same group, false otherwise.  DESTROY will be called when
47    the casegrouper is destroyed and should free any storage
48    needed by SAME_GROUP.
49
50    SAME_GROUP may be a null pointer.  If so, READER's entire
51    contents is considered to be a single group. */
52 struct casegrouper *
53 casegrouper_create_func (struct casereader *reader,
54                          bool (*same_group) (const struct ccase *,
55                                              const struct ccase *,
56                                              void *aux),
57                          void (*destroy) (void *aux),
58                          void *aux)
59 {
60   struct casegrouper *grouper = xmalloc (sizeof *grouper);
61   grouper->reader = casereader_rename (reader);
62   grouper->taint = taint_clone (casereader_get_taint (grouper->reader));
63   grouper->same_group = same_group;
64   grouper->destroy = destroy;
65   grouper->aux = aux;
66   return grouper;
67 }
68
69 /* Obtains the next group of cases from GROUPER.  Returns true if
70    successful, false if no groups remain.  If successful, *READER
71    is set to the casereader for the new group; otherwise, it is
72    set to NULL. */
73 bool
74 casegrouper_get_next_group (struct casegrouper *grouper,
75                             struct casereader **reader)
76 {
77   /* FIXME: we really shouldn't need a temporary casewriter for
78      the common case where we read an entire group's data before
79      going on to the next. */
80   if (grouper->same_group != NULL)
81     {
82       struct casewriter *writer;
83       struct ccase *group_case, *tmp;
84
85       group_case = casereader_read (grouper->reader);
86       if (group_case == NULL)
87         {
88           *reader = NULL;
89           return false;
90         }
91
92       writer = autopaging_writer_create (
93         casereader_get_proto (grouper->reader));
94
95       casewriter_write (writer, case_ref (group_case));
96
97       while ((tmp = casereader_peek (grouper->reader, 0)) != NULL
98              && grouper->same_group (group_case, tmp, grouper->aux))
99         {
100           case_unref (casereader_read (grouper->reader));
101           casewriter_write (writer, tmp);
102         }
103       case_unref (tmp);
104       case_unref (group_case);
105
106       *reader = casewriter_make_reader (writer);
107       return true;
108     }
109   else
110     {
111       if (grouper->reader != NULL)
112         {
113           if (!casereader_is_empty (grouper->reader))
114             {
115               *reader = grouper->reader;
116               grouper->reader = NULL;
117               return true;
118             }
119           else
120             {
121               casereader_destroy (grouper->reader);
122               grouper->reader = NULL;
123               return false;
124             }
125         }
126       else
127         {
128           *reader = NULL;
129           return false;
130         }
131     }
132 }
133
134 /* Destroys GROUPER.  Returns false if GROUPER's input casereader
135    or any state derived from it had become tainted, which means
136    that an I/O error or other serious error occurred in
137    processing data derived from GROUPER; otherwise, return true. */
138 bool
139 casegrouper_destroy (struct casegrouper *grouper)
140 {
141   if (grouper != NULL)
142     {
143       struct taint *taint = grouper->taint;
144       bool ok;
145
146       casereader_destroy (grouper->reader);
147       if (grouper->destroy != NULL)
148         grouper->destroy (grouper->aux);
149       free (grouper);
150
151       ok = !taint_has_tainted_successor (taint);
152       taint_destroy (taint);
153       return ok;
154     }
155   else
156     return true;
157 }
158 \f
159 /* Casegrouper based on equal values of variables from case to
160    case. */
161
162 static bool casegrouper_vars_same_group (const struct ccase *,
163                                          const struct ccase *,
164                                          void *);
165 static void casegrouper_vars_destroy (void *);
166
167 /* Creates and returns a casegrouper that reads data from READER
168    and breaks it into contiguous groups of cases that have equal
169    values for the VAR_CNT variables in VARS.  If VAR_CNT is 0,
170    then all the cases will be put in a single group. */
171 struct casegrouper *
172 casegrouper_create_vars (struct casereader *reader,
173                          const struct variable *const *vars,
174                          size_t var_cnt)
175 {
176   if (var_cnt > 0) 
177     {
178       struct subcase *sc = xmalloc (sizeof *sc);
179       subcase_init_vars (sc, vars, var_cnt);
180       return casegrouper_create_func (reader, casegrouper_vars_same_group,
181                                       casegrouper_vars_destroy, sc); 
182     }
183   else
184     return casegrouper_create_func (reader, NULL, NULL, NULL);
185 }
186
187 /* Creates and returns a casegrouper that reads data from READER
188    and breaks it into contiguous groups of cases that have equal
189    values for the SPLIT FILE variables in DICT.  If DICT has no
190    SPLIT FILE variables, then all the cases will be put into a
191    single group. */
192 struct casegrouper *
193 casegrouper_create_splits (struct casereader *reader,
194                            const struct dictionary *dict)
195 {
196   return casegrouper_create_vars (reader,
197                                   dict_get_split_vars (dict),
198                                   dict_get_split_cnt (dict));
199 }
200
201 /* Creates and returns a casegrouper that reads data from READER
202    and breaks it into contiguous groups of cases that have equal
203    values for the variables used for sorting in SC.  If SC is
204    empty (contains no fields), then all the cases will be put
205    into a single group. */
206 struct casegrouper *
207 casegrouper_create_subcase (struct casereader *reader,
208                             const struct subcase *sc)
209 {
210   if (subcase_get_n_fields (sc) > 0) 
211     {
212       struct subcase *sc_copy = xmalloc (sizeof *sc);
213       subcase_clone (sc_copy, sc);
214       return casegrouper_create_func (reader, casegrouper_vars_same_group,
215                                       casegrouper_vars_destroy, sc_copy); 
216     }
217   else
218     return casegrouper_create_func (reader, NULL, NULL, NULL);
219 }
220
221 /* "same_group" function for an equal-variables casegrouper. */
222 static bool
223 casegrouper_vars_same_group (const struct ccase *a, const struct ccase *b,
224                              void *sc_)
225 {
226   struct subcase *sc = sc_;
227   return subcase_equal (sc, a, sc, b);
228 }
229
230 /* "destroy" for an equal-variables casegrouper. */
231 static void
232 casegrouper_vars_destroy (void *sc_)
233 {
234   struct subcase *sc = sc_;
235   if (sc != NULL) 
236     {
237       subcase_destroy (sc);
238       free (sc); 
239     }
240 }