pintos-os.org Git - pspp/blob - src/output/table-paste.c

   1 /* PSPP - a program for statistical analysis.
   2    Copyright (C) 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 "libpspp/assertion.h"
  20 #include "libpspp/tower.h"
  21 #include "output/table-provider.h"
  22
  23 #include "gl/minmax.h"
  24 #include "gl/xalloc.h"
  25
  26 struct paste_subtable
  27   {
  28     struct tower_node node;
  29     struct table *table;
  30   };
  31
  32 static struct paste_subtable *
  33 paste_subtable_cast (struct tower_node *node)
  34 {
  35   return tower_data (node, struct paste_subtable, node);
  36 }
  37
  38 struct table_paste
  39   {
  40     struct table table;
  41     struct tower subtables;
  42     enum table_axis orientation;
  43   };
  44
  45 static const struct table_class table_paste_class;
  46
  47 static struct table_paste *
  48 table_paste_cast (const struct table *table)
  49 {
  50   assert (table->klass == &table_paste_class);
  51   return UP_CAST (table, struct table_paste, table);
  52 }
  53
  54 static bool
  55 is_table_paste (const struct table *table, int orientation)
  56 {
  57   return (table->klass == &table_paste_class
  58           && table_paste_cast (table)->orientation == orientation);
  59 }
  60
  61 static struct paste_subtable *
  62 paste_subtable_lookup (struct table_paste *tp, unsigned long int offset,
  63                        unsigned long int *start)
  64 {
  65   return paste_subtable_cast (tower_lookup (&tp->subtables, offset, start));
  66 }
  67
  68 /* This must be called *before* adding TABLE to TP, otherwise the test for
  69    whether TP is empty will not have the correct effect. */
  70 static void
  71 table_paste_increase_size (struct table_paste *tp,
  72                            const struct table *table)
  73 {
  74   int o = tp->orientation;
  75   int h0, h1;
  76
  77   tp->table.n[o] += table->n[o];
  78   tp->table.n[!o] = MAX (tp->table.n[!o], table->n[!o]);
  79
  80   h0 = table->h[!o][0];
  81   h1 = table->h[!o][1];
  82   if (tower_is_empty (&tp->subtables))
  83     {
  84       tp->table.h[!o][0] = h0;
  85       tp->table.h[!o][1] = h1;
  86     }
  87   else
  88     {
  89       tp->table.h[!o][0] = MIN (tp->table.h[!o][0], h0);
  90
  91       /* XXX this is not quite right */
  92       tp->table.h[!o][1] = MIN (tp->table.h[!o][1], h1);
  93     }
  94 }
  95
  96 static void
  97 reassess_headers (struct table_paste *tp)
  98 {
  99   int o = tp->orientation;
 100   if (tower_is_empty (&tp->subtables))
 101     tp->table.h[o][0] = tp->table.h[o][1] = 0;
 102   else
 103     {
 104       struct paste_subtable *h0, *h1;
 105
 106       h0 = paste_subtable_cast (tower_first (&tp->subtables));
 107       tp->table.h[o][0] = h0->table->h[o][0];
 108
 109       h1 = paste_subtable_cast (tower_last (&tp->subtables));
 110       tp->table.h[o][1] = h1->table->h[o][1];
 111     }
 112 }
 113
 114 static void
 115 table_paste_insert_subtable (struct table_paste *tp,
 116                              struct table *table,
 117                              struct tower_node *under)
 118 {
 119   struct paste_subtable *subtable;
 120
 121   subtable = xmalloc (sizeof *subtable);
 122   table_paste_increase_size (tp, table);
 123   tower_insert (&tp->subtables, table->n[tp->orientation],
 124                 &subtable->node, under);
 125   subtable->table = table;
 126   reassess_headers (tp);
 127 }
 128
 129 /* Takes ownership of A and B and returns a table that consists of tables A and
 130    B "pasted together", that is, a table whose size is the sum of the sizes of
 131    A and B along the axis specified by ORIENTATION.  A and B should have the
 132    same size along the axis opposite ORIENTATION; the handling of tables that
 133    have different sizes along that axis may vary.
 134
 135    The rules at the seam between A and B are combined.  The exact way in which
 136    they are combined is unspecified, but the method of table_rule_combine() is
 137    typical.
 138
 139    If A or B is null, returns the other argument. */
 140 struct table *
 141 table_paste (struct table *a, struct table *b, enum table_axis orientation)
 142 {
 143   struct table_paste *tp;
 144
 145   /* Handle nulls. */
 146   if (a == NULL)
 147     return b;
 148   if (b == NULL)
 149     return a;
 150
 151   /* Handle tables that know how to paste themselves. */
 152   if (!table_is_shared (a) && !table_is_shared (b) && a != b)
 153     {
 154       if (a->klass->paste != NULL)
 155         {
 156           struct table *new = a->klass->paste (a, b, orientation);
 157           if (new != NULL)
 158             return new;
 159         }
 160       if (b->klass->paste != NULL && a->klass != b->klass)
 161         {
 162           struct table *new = b->klass->paste (a, b, orientation);
 163           if (new != NULL)
 164             return new;
 165         }
 166     }
 167
 168   /* Create new table_paste and insert A and B into it. */
 169   tp = xmalloc (sizeof *tp);
 170   table_init (&tp->table, &table_paste_class);
 171   tower_init (&tp->subtables);
 172   tp->orientation = orientation;
 173   table_paste_insert_subtable (tp, a, NULL);
 174   table_paste_insert_subtable (tp, b, NULL);
 175   return &tp->table;
 176 }
 177
 178 /* Shorthand for table_paste (left, right, TABLE_HORZ). */
 179 struct table *
 180 table_hpaste (struct table *left, struct table *right)
 181 {
 182   return table_paste (left, right, TABLE_HORZ);
 183 }
 184
 185 /* Shorthand for table_paste (left, right, TABLE_VERT). */
 186 struct table *
 187 table_vpaste (struct table *left, struct table *right)
 188 {
 189   return table_paste (left, right, TABLE_VERT);
 190 }
 191
 192 static void
 193 table_paste_destroy (struct table *t)
 194 {
 195   struct table_paste *tp = table_paste_cast (t);
 196   struct tower_node *node, *next;
 197
 198   for (node = tower_first (&tp->subtables); node != NULL; node = next)
 199     {
 200       struct paste_subtable *ps = paste_subtable_cast (node);
 201       table_unref (ps->table);
 202       next = tower_delete (&tp->subtables, node);
 203       free (node);
 204     }
 205   free (tp);
 206 }
 207
 208 static void
 209 table_paste_get_cell (const struct table *t, int x, int y,
 210                       struct table_cell *cell)
 211 {
 212   struct table_paste *tp = table_paste_cast (t);
 213   struct paste_subtable *ps;
 214   unsigned long int start;
 215   int d[TABLE_N_AXES];
 216
 217   d[TABLE_HORZ] = x;
 218   d[TABLE_VERT] = y;
 219   ps = paste_subtable_lookup (tp, d[tp->orientation], &start);
 220   d[tp->orientation] -= start;
 221   table_get_cell (ps->table, d[TABLE_HORZ], d[TABLE_VERT], cell);
 222   cell->d[tp->orientation][0] += start;
 223   cell->d[tp->orientation][1] += start;
 224 }
 225
 226 static int
 227 table_paste_get_rule (const struct table *t,
 228                       enum table_axis axis, int x, int y)
 229 {
 230   struct table_paste *tp = table_paste_cast (t);
 231   int h = tp->orientation == TABLE_HORZ ? x : y;
 232   int k = tp->orientation == TABLE_HORZ ? y : x;
 233   struct paste_subtable *ps;
 234   unsigned long int start;
 235
 236   if (tp->orientation == axis)
 237     {
 238       int r;
 239
 240       ps = paste_subtable_lookup (tp, h == 0 ? 0 : h - 1, &start);
 241       if (tp->orientation == TABLE_HORZ) /* XXX */
 242         r = table_get_rule (ps->table, axis, h - start, k);
 243       else
 244         r = table_get_rule (ps->table, axis, k, h - start);
 245       if (h == start + tower_node_get_size (&ps->node))
 246         {
 247           struct tower_node *ps2_ = tower_next (&tp->subtables, &ps->node);
 248           if (ps2_ != NULL)
 249             {
 250               struct paste_subtable *ps2 = paste_subtable_cast (ps2_);
 251               int r2;
 252
 253               if (tp->orientation == TABLE_HORZ) /* XXX */
 254                 r2 = table_get_rule (ps2->table, axis, 0, k);
 255               else
 256                 r2 = table_get_rule (ps2->table, axis, k, 0);
 257               return table_rule_combine (r, r2);
 258             }
 259         }
 260       return r;
 261     }
 262   else
 263     {
 264       ps = paste_subtable_lookup (tp, h, &start);
 265       if (tp->orientation == TABLE_HORZ) /* XXX */
 266         return table_get_rule (ps->table, axis, h - start, k);
 267       else
 268         return table_get_rule (ps->table, axis, k, h - start);
 269     }
 270 }
 271
 272 static struct table *
 273 table_paste_paste (struct table *a, struct table *b,
 274                    enum table_axis orientation)
 275 {
 276   struct table_paste *ta, *tb;
 277
 278   ta = is_table_paste (a, orientation) ? table_paste_cast (a) : NULL;
 279   tb = is_table_paste (b, orientation) ? table_paste_cast (b) : NULL;
 280
 281   if (ta != NULL)
 282     {
 283       if (tb != NULL)
 284         {
 285           /* Append all of B's subtables onto A, then destroy B. */
 286           table_paste_increase_size (ta, b);
 287           tower_splice (&ta->subtables, NULL,
 288                         &tb->subtables, tower_first (&tb->subtables), NULL);
 289           table_unref (b);
 290         }
 291       else
 292         {
 293           /* Append B to A's stack of subtables. */
 294           table_paste_insert_subtable (ta, b, NULL);
 295         }
 296       reassess_headers (ta);
 297       return a;
 298     }
 299   else if (tb != NULL)
 300     {
 301       /* Insert A at the beginning of B's stack of subtables. */
 302       table_paste_insert_subtable (tb, a, tower_first (&tb->subtables));
 303       reassess_headers (tb);
 304       return b;
 305     }
 306   else
 307     return NULL;
 308 }
 309
 310 static const struct table_class table_paste_class =
 311   {
 312     table_paste_destroy,
 313     table_paste_get_cell,
 314     table_paste_get_rule,
 315     table_paste_paste,
 316     NULL,                       /* select */
 317   };