CORRELATIONS: Fixed bug displaying non-sqaure correlation matrices
[pspp] / src / data / attributes.c
1 /* PSPP - a program for statistical analysis.
2    Copyright (C) 2008, 2009, 2011, 2012 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/attributes.h"
20
21 #include <assert.h>
22 #include <string.h>
23
24 #include "libpspp/array.h"
25 #include "libpspp/hash-functions.h"
26
27 #include "gl/xalloc.h"
28
29 /* A custom attribute of the sort maintained by the DATAFILE
30    ATTRIBUTE and VARIABLE ATTRIBUTE commands.
31
32    Attributes have a name (the rules for which are the same as
33    those for PSPP variable names) and one or more values, each of
34    which is a string.  An attribute may be part of one attribute
35    set. */
36 struct attribute
37   {
38     struct hmap_node node;      /* Used by attrset. */
39     char *name;                 /* Name. */
40     char **values;              /* Each value. */
41     size_t n_values;            /* Number of values. */
42     size_t allocated_values;    /* Amount of allocated space for values. */
43   };
44
45 /* Creates and returns a new attribute with the given NAME.  The
46    attribute initially has no values.  (Attributes with no values
47    cannot be saved to system files, so at least one value should
48    be added before the attribute is made available to the PSPP
49    user.) */
50 struct attribute *
51 attribute_create (const char *name)
52 {
53   struct attribute *attr = xmalloc (sizeof *attr);
54   attr->name = xstrdup (name);
55   attr->values = NULL;
56   attr->n_values = 0;
57   attr->allocated_values = 0;
58   return attr;
59 }
60
61 /* Creates and returns a new attribute with the same name and
62    values as ORIG. */
63 struct attribute *
64 attribute_clone (const struct attribute *orig)
65 {
66   struct attribute *attr;
67   size_t i;
68
69   attr = attribute_create (orig->name);
70   for (i = 0; i < orig->n_values; i++)
71     attribute_add_value (attr, orig->values[i]);
72   return attr;
73 }
74
75 /* Destroys ATTR and frees all associated memory.
76
77    This function must not be called if ATTR is part of an
78    attribute set.  Use attrset_delete() instead. */
79 void
80 attribute_destroy (struct attribute *attr)
81 {
82   if (attr != NULL)
83     {
84       size_t i;
85
86       for (i = 0; i < attr->n_values; i++)
87         free (attr->values[i]);
88       free (attr->values);
89       free (attr->name);
90       free (attr);
91     }
92 }
93
94 /* Returns the name of ATTR.  The caller must not free or modify
95    the returned string. */
96 const char *
97 attribute_get_name (const struct attribute *attr)
98 {
99   return attr->name;
100 }
101
102 /* Returns ATTR's value with the given INDEX, or a null pointer
103    if INDEX is greater than or equal to the number of values in
104    ATTR (that is, attributes are numbered starting from 0).  The
105    caller must not free or modify the returned string.  */
106 const char *
107 attribute_get_value (const struct attribute *attr, size_t index)
108 {
109   return index < attr->n_values ? attr->values[index] : NULL;
110 }
111
112 /* Returns ATTR's number of values. */
113 size_t
114 attribute_get_n_values (const struct attribute *attrs)
115 {
116   return attrs->n_values;
117 }
118
119 /* Adds a copy of VALUE as a new value to ATTR.  The caller
120    retains ownership of VALUE. */
121 void
122 attribute_add_value (struct attribute *attr, const char *value)
123 {
124   if (attr->n_values >= attr->allocated_values)
125     attr->values = x2nrealloc (attr->values, &attr->allocated_values,
126                                sizeof *attr->values);
127   attr->values[attr->n_values++] = xstrdup (value);
128 }
129
130 /* Adds or replaces the value with the given INDEX in ATTR by a
131    copy of VALUE.  The caller retains ownership of VALUE.
132
133    If INDEX is an existing value index, that value is replaced.
134    If no value index numbered INDEX exists in ATTR, then it is
135    added, and any values intermediate between the last maximum
136    index and INDEX are set to the empty string. */
137 void
138 attribute_set_value (struct attribute *attr, size_t index, const char *value)
139 {
140   if (index < attr->n_values)
141     {
142       /* Replace existing value. */
143       free (attr->values[index]);
144       attr->values[index] = xstrdup (value);
145     }
146   else
147     {
148       /* Add new value. */
149       while (index > attr->n_values)
150         attribute_add_value (attr, "");
151       attribute_add_value (attr, value);
152     }
153
154 }
155
156 /* Deletes the value with the given INDEX from ATTR.  Any values
157    with higher-numbered indexes are shifted down into the gap
158    that this creates.
159
160    If INDEX is greater than the maximum index, this has no effect.*/
161 void
162 attribute_del_value (struct attribute *attr, size_t index)
163 {
164   if (index < attr->n_values)
165     {
166       free (attr->values[index]);
167       remove_element (attr->values, attr->n_values, sizeof *attr->values,
168                       index);
169       attr->n_values--;
170     }
171 }
172 \f
173 /* Initializes SET as a new, initially empty attibute set. */
174 void
175 attrset_init (struct attrset *set)
176 {
177   hmap_init (&set->map);
178 }
179
180 /* Initializes NEW_SET as a new attribute set whose contents are
181    initially the same as that of OLD_SET. */
182 void
183 attrset_clone (struct attrset *new_set, const struct attrset *old_set)
184 {
185   struct attribute *old_attr;
186
187   attrset_init (new_set);
188   HMAP_FOR_EACH (old_attr, struct attribute, node, &old_set->map)
189     {
190       struct attribute *new_attr = attribute_clone (old_attr);
191       hmap_insert (&new_set->map, &new_attr->node,
192                    hmap_node_hash (&old_attr->node));
193     }
194 }
195
196 /* Frees the storage associated with SET, if SET is nonnull.
197    (Does not free SET itself.) */
198 void
199 attrset_destroy (struct attrset *set)
200 {
201   if (set != NULL)
202     {
203       struct attribute *attr, *next;
204
205       HMAP_FOR_EACH_SAFE (attr, next, struct attribute, node, &set->map)
206         attribute_destroy (attr);
207       hmap_destroy (&set->map);
208     }
209 }
210
211 /* Returns the number of attributes in SET. */
212 size_t
213 attrset_count (const struct attrset *set)
214 {
215   return hmap_count (&set->map);
216 }
217
218 /* Returns the attribute in SET whose name matches NAME
219    case-insensitively, or a null pointer if SET does not contain
220    an attribute with that name. */
221 struct attribute *
222 attrset_lookup (struct attrset *set, const char *name)
223 {
224   struct attribute *attr;
225   HMAP_FOR_EACH_WITH_HASH (attr, struct attribute, node,
226                            hash_case_string (name, 0), &set->map)
227     if (!strcasecmp (attribute_get_name (attr), name))
228       break;
229   return attr;
230 }
231
232 /* Adds ATTR to SET, which must not already contain an attribute
233    with the same name (matched case insensitively).  Ownership of
234    ATTR is transferred to SET. */
235 void
236 attrset_add (struct attrset *set, struct attribute *attr)
237 {
238   const char *name = attribute_get_name (attr);
239   assert (attrset_lookup (set, name) == NULL);
240   hmap_insert (&set->map, &attr->node, hash_case_string (name, 0));
241 }
242
243 /* Deletes any attribute from SET that matches NAME
244    (case-insensitively). */
245 void
246 attrset_delete (struct attrset *set, const char *name)
247 {
248   struct attribute *attr = attrset_lookup (set, name);
249   if (attr != NULL)
250     {
251       hmap_delete (&set->map, &attr->node);
252       attribute_destroy (attr);
253     }
254 }
255
256 /* Deletes all attributes from SET. */
257 void
258 attrset_clear (struct attrset *set)
259 {
260   attrset_destroy (set);
261   attrset_init (set);
262 }
263
264 static struct attribute *iterator_data (struct attrset_iterator *iterator)
265 {
266   return HMAP_NULLABLE_DATA (iterator->node, struct attribute, node);
267 }
268
269 /* Returns the first attribute in SET and initializes ITERATOR.
270    If SET is empty, returns a null pointer.
271
272    The caller must not destroy the returned attribute, but it may
273    add or remove values.
274
275    Attributes are visited in no particular order.  Calling
276    attrset_add() during iteration can cause some attributes to
277    be visited more than once and others not at all. */
278 struct attribute *
279 attrset_first (const struct attrset *set, struct attrset_iterator *iterator)
280 {
281   iterator->node = hmap_first (&set->map);
282   return iterator_data (iterator);
283 }
284
285 /* Returns the next attribute in SET and advances ITERATOR, which
286    should have been initialized by calling attrset_first().  If
287    all the attributes in SET have already been visited, returns a
288    null pointer.
289
290    The caller must not destroy the returned attribute, but it may
291    add or remove values.
292
293    Attributes are visited in no particular order.  Calling
294    attrset_add() during iteration can cause some attributes to
295    be visited more than once and others not at all. */
296 struct attribute *
297 attrset_next (const struct attrset *set, struct attrset_iterator *iterator)
298 {
299   iterator->node = hmap_next (&set->map, iterator->node);
300   return iterator_data (iterator);
301 }
302
303 static int
304 compare_attribute_by_name (const void *a_, const void *b_)
305 {
306   const struct attribute *const *a = a_;
307   const struct attribute *const *b = b_;
308
309   return strcmp ((*a)->name, (*b)->name);
310 }
311
312 /* Allocates and returns an array of pointers to attributes
313    that is sorted by attribute name.  The array has
314    'attrset_count (SET)' elements.  The caller is responsible for
315    freeing the array. */
316 struct attribute **
317 attrset_sorted (const struct attrset *set)
318 {
319   if (set != NULL && attrset_count (set) > 0)
320     {
321       struct attribute **attrs;
322       struct attribute *attr;
323       size_t i;
324
325       attrs = xmalloc (attrset_count (set) * sizeof *attrs);
326       i = 0;
327       HMAP_FOR_EACH (attr, struct attribute, node, &set->map)
328         attrs[i++] = attr;
329       assert (i == attrset_count (set));
330       qsort (attrs, attrset_count (set), sizeof *attrs,
331              compare_attribute_by_name);
332       return attrs;
333     }
334   else
335     return NULL;
336 }