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

   1 /* PSPP - a program for statistical analysis.
   2    Copyright (C) 2009, 2011, 2014 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   assert (a->n[!orientation] == b->n[!orientation]);
 152
 153   /* Handle tables that know how to paste themselves. */
 154   if (!table_is_shared (a) && !table_is_shared (b) && a != b)
 155     {
 156       if (a->klass->paste != NULL)
 157         {
 158           struct table *new = a->klass->paste (a, b, orientation);
 159           if (new != NULL)
 160             return new;
 161         }
 162       if (b->klass->paste != NULL && a->klass != b->klass)
 163         {
 164           struct table *new = b->klass->paste (a, b, orientation);
 165           if (new != NULL)
 166             return new;
 167         }
 168     }
 169
 170   /* Create new table_paste and insert A and B into it. */
 171   tp = xmalloc (sizeof *tp);
 172   table_init (&tp->table, &table_paste_class);
 173   tower_init (&tp->subtables);
 174   tp->orientation = orientation;
 175   table_paste_insert_subtable (tp, a, NULL);
 176   table_paste_insert_subtable (tp, b, NULL);
 177   return &tp->table;
 178 }
 179
 180 /* Shorthand for table_paste (left, right, TABLE_HORZ). */
 181 struct table *
 182 table_hpaste (struct table *left, struct table *right)
 183 {
 184   return table_paste (left, right, TABLE_HORZ);
 185 }
 186
 187 /* Shorthand for table_paste (top, bottom, TABLE_VERT). */
 188 struct table *
 189 table_vpaste (struct table *top, struct table *bottom)
 190 {
 191   return table_paste (top, bottom, TABLE_VERT);
 192 }
 193
 194 static void
 195 table_paste_destroy (struct table *t)
 196 {
 197   struct table_paste *tp = table_paste_cast (t);
 198   struct tower_node *node, *next;
 199
 200   for (node = tower_first (&tp->subtables); node != NULL; node = next)
 201     {
 202       struct paste_subtable *ps = paste_subtable_cast (node);
 203       table_unref (ps->table);
 204       next = tower_delete (&tp->subtables, node);
 205       free (node);
 206     }
 207   free (tp);
 208 }
 209
 210 static void
 211 table_paste_get_cell (const struct table *t, int x, int y,
 212                       struct table_cell *cell)
 213 {
 214   struct table_paste *tp = table_paste_cast (t);
 215   struct paste_subtable *ps;
 216   unsigned long int start;
 217   int d[TABLE_N_AXES];
 218
 219   d[TABLE_HORZ] = x;
 220   d[TABLE_VERT] = y;
 221   ps = paste_subtable_lookup (tp, d[tp->orientation], &start);
 222   d[tp->orientation] -= start;
 223   table_get_cell (ps->table, d[TABLE_HORZ], d[TABLE_VERT], cell);
 224   cell->d[tp->orientation][0] += start;
 225   cell->d[tp->orientation][1] += start;
 226 }
 227
 228 static int
 229 table_paste_get_rule (const struct table *t,
 230                       enum table_axis axis, int x, int y,
 231                       struct cell_color *color)
 232 {
 233   struct table_paste *tp = table_paste_cast (t);
 234   int h = tp->orientation == TABLE_HORZ ? x : y;
 235   int k = tp->orientation == TABLE_HORZ ? y : x;
 236   struct paste_subtable *ps;
 237   unsigned long int start;
 238
 239   if (tp->orientation == axis)
 240     {
 241       int r;
 242
 243       ps = paste_subtable_lookup (tp, h == 0 ? 0 : h - 1, &start);
 244       if (tp->orientation == TABLE_HORZ) /* XXX */
 245         r = table_get_rule (ps->table, axis, h - start, k, color);
 246       else
 247         r = table_get_rule (ps->table, axis, k, h - start, color);
 248       if (h == start + tower_node_get_size (&ps->node))
 249         {
 250           struct tower_node *ps2_ = tower_next (&tp->subtables, &ps->node);
 251           if (ps2_ != NULL)
 252             {
 253               struct paste_subtable *ps2 = paste_subtable_cast (ps2_);
 254               int r2;
 255
 256               if (tp->orientation == TABLE_HORZ) /* XXX */
 257                 r2 = table_get_rule (ps2->table, axis, 0, k, color);
 258               else
 259                 r2 = table_get_rule (ps2->table, axis, k, 0, color);
 260               return table_rule_combine (r, r2);
 261             }
 262         }
 263       return r;
 264     }
 265   else
 266     {
 267       ps = paste_subtable_lookup (tp, h, &start);
 268       if (tp->orientation == TABLE_HORZ) /* XXX */
 269         return table_get_rule (ps->table, axis, h - start, k, color);
 270       else
 271         return table_get_rule (ps->table, axis, k, h - start, color);
 272     }
 273 }
 274
 275 static struct table *
 276 table_paste_paste (struct table *a, struct table *b,
 277                    enum table_axis orientation)
 278 {
 279   struct table_paste *ta, *tb;
 280
 281   ta = is_table_paste (a, orientation) ? table_paste_cast (a) : NULL;
 282   tb = is_table_paste (b, orientation) ? table_paste_cast (b) : NULL;
 283
 284   if (ta != NULL)
 285     {
 286       if (tb != NULL)
 287         {
 288           /* Append all of B's subtables onto A, then destroy B. */
 289           table_paste_increase_size (ta, b);
 290           tower_splice (&ta->subtables, NULL,
 291                         &tb->subtables, tower_first (&tb->subtables), NULL);
 292           table_unref (b);
 293         }
 294       else
 295         {
 296           /* Append B to A's stack of subtables. */
 297           table_paste_insert_subtable (ta, b, NULL);
 298         }
 299       reassess_headers (ta);
 300       return a;
 301     }
 302   else if (tb != NULL)
 303     {
 304       /* Insert A at the beginning of B's stack of subtables. */
 305       table_paste_insert_subtable (tb, a, tower_first (&tb->subtables));
 306       reassess_headers (tb);
 307       return b;
 308     }
 309   else
 310     return NULL;
 311 }
 312
 313 static const struct table_class table_paste_class =
 314   {
 315     table_paste_destroy,
 316     table_paste_get_cell,
 317     table_paste_get_rule,
 318     table_paste_paste,
 319     NULL,                       /* select */
 320   };