ermyth/src/table.C

/*
 * table.C: Table rendering class.
 * Rights to this code are documented in doc/LICENSE.
 *
 * NOTE: This is a work in progress and will probably change considerably
 * later on.
 *
 * Copyright © 2005-2007 Atheme Project (http://www.atheme.org)
 */

static char const rcsid[] = "$Id";

#include "atheme.h"

static void
table_destroy (void *obj)
{
  table_t *table = (table_t *) obj;
  node_t *n, *tn;

  return_if_fail (table != NULL);

  LIST_FOREACH_SAFE (n, tn, table->rows.head)
  {
    table_row_t *r = (table_row_t *) n->data;
    node_t *n2, *tn2;

    return_if_fail (r != NULL);

    LIST_FOREACH_SAFE (n2, tn2, r->cells.head)
    {
      table_cell_t *c = (table_cell_t *) n2->data;

      free (c->name);
      free (c->value);
      free (c);
      node_del (n2, &r->cells);
      node_free (n2);
    }

    free (r);

    node_del (n, &table->rows);
    node_free (n);
  }

  free (table);
}

/*
 * table_new(const char *fmt, ...)
 *
 * Table constructor.
 *
 * Inputs:
 *     - printf-style string to name the table with.
 *
 * Outputs:
 *     - a table object.
 *
 * Side Effects:
 *     - none
 */
table_t *
table_new (const char *fmt, ...)
{
  va_list vl;
  char *buf;
  table_t *out;

  return_val_if_fail (fmt != NULL, NULL);

  va_start (vl, fmt);
  vasprintf (&buf, fmt, vl);
  va_end (vl);

  out = static_cast<table_t *> (scalloc (sizeof (table_t), 1));
  object_init (&out->parent, buf, table_destroy);
  free (buf);

  return out;
}

/*
 * table_row_new
 *
 * Creates a table row. This isn't an object.
 *
 * Inputs:
 *     - table to associate to.
 *
 * Outputs:
 *     - a table row
 *
 * Side Effects:
 *     - none
 */
table_row_t *
table_row_new (table_t * t)
{
  table_row_t *out;

  return_val_if_fail (t != NULL, NULL);

  out = static_cast<table_row_t *> (scalloc (sizeof (table_row_t), 1));

  node_add (out, node_create (), &t->rows);

  return out;
}

/*
 * table_cell_associate
 *
 * Associates a cell with a row.
 *
 * Inputs:
 *     - row to add cell to.
 *
 * Outputs:
 *     - nothing
 *
 * Side Effects:
 *     - none
 */
void
table_cell_associate (table_row_t * r, const char *name, const char *value)
{
  table_cell_t *c;

  return_if_fail (r != NULL);
  return_if_fail (name != NULL);
  return_if_fail (value != NULL);

  c = static_cast<table_cell_t *> (scalloc (sizeof (table_cell_t), 1));

  c->name = sstrdup (name);
  c->value = sstrdup (value);

  node_add (c, node_create (), &r->cells);
}

/*
 * table_render
 *
 * Renders a table. This is a two-pass operation, the first one to find out
 * the width of each cell, and then the second to render the data.
 *
 * Inputs:
 *     - a table
 *     - a callback function
 *     - opaque data
 *
 * Outputs:
 *     - none
 *
 * Side Effects:
 *     - a callback function is called for each row of the table.
 */
void
table_render (table_t * t, void (*callback) (const char *line, void *data), void *data)
{
  node_t *n;
  table_row_t *f;
  size_t bufsz = 0;
  char *buf = NULL;
  char *p;
  int i;

  return_if_fail (t != NULL);
  return_if_fail (callback != NULL);

  f = (table_row_t *) t->rows.head->data;

  LIST_FOREACH (n, t->rows.head)
  {
    table_row_t *r = (table_row_t *) n->data;
    node_t *n2, *rn;

    /* we, uhh... we don't provide a macro for dealing with two lists at once ;) */
    for (n2 = r->cells.head, rn = f->cells.head; n2 != NULL && rn != NULL; n2 = n2->next, rn = rn->next)
      {
        table_cell_t *c, *rc;
        size_t sz;

        c = (table_cell_t *) n2->data;
        rc = (table_cell_t *) rn->data;

        if ((sz = strlen (c->name)) > (size_t) rc->width)
          rc->width = sz;

        if ((sz = strlen (c->value)) > (size_t) rc->width)
          rc->width = sz;
      }
  }

  /* now total up the result. */
  LIST_FOREACH (n, f->cells.head)
  {
    table_cell_t *c = (table_cell_t *) n->data;
    bufsz += c->width + 1;
  }

  buf = static_cast<char *> (smalloc (bufsz));
  *buf = '\0';

  /* start outputting the header. */
  callback (asobject (t)->name, data);
  LIST_FOREACH (n, f->cells.head)
  {
    table_cell_t *c = (table_cell_t *) n->data;
    char fmtbuf[12];
    char buf2[1024];

    /* dynamically generate the format string based on width. */
    snprintf (fmtbuf, 12, n->next != NULL ? "%%-%ds " : "%%s", c->width);
    snprintf (buf2, 1024, fmtbuf, c->name);

    strlcat (buf, buf2, bufsz);
  }
  callback (buf, data);
  *buf = '\0';

  /* separator line */
  p = buf;
  LIST_FOREACH (n, f->cells.head)
  {
    table_cell_t *c = (table_cell_t *) n->data;

    if (n->next != NULL)
      {
        for (i = 0; i < c->width; i++)
          *p++ = '-';
        *p++ = ' ';
      }
    else
      for (i = 0; i < (int) strlen (c->name); i++)
        *p++ = '-';
  }
  *p = '\0';
  callback (buf, data);
  *buf = '\0';

  LIST_FOREACH (n, t->rows.head)
  {
    table_row_t *r = (table_row_t *) n->data;
    node_t *n2, *rn;

    for (n2 = r->cells.head, rn = f->cells.head; n2 != NULL && rn != NULL; n2 = n2->next, rn = rn->next)
      {
        table_cell_t *c, *rc;
        char fmtbuf[12];
        char buf2[1024];

        c = (table_cell_t *) n2->data;
        rc = (table_cell_t *) rn->data;

        /* dynamically generate the format string based on width. */
        snprintf (fmtbuf, 12, n2->next != NULL ? "%%-%ds " : "%%s", rc->width);
        snprintf (buf2, 1024, fmtbuf, c->value);

        strlcat (buf, buf2, bufsz);
      }
    callback (buf, data);
    *buf = '\0';
  }

  /* separator line */
  p = buf;
  LIST_FOREACH (n, f->cells.head)
  {
    table_cell_t *c = (table_cell_t *) n->data;

    if (n->next != NULL)
      {
        for (i = 0; i < c->width; i++)
          *p++ = '-';
        *p++ = ' ';
      }
    else
      for (i = 0; i < (int) strlen (c->name); i++)
        *p++ = '-';
  }
  *p = '\0';
  callback (buf, data);
  *buf = '\0';
}

/* vim:cinoptions=>s,e0,n0,f0,{0,}0,^0,=s,ps,t0,c3,+s,(2s,us,)20,*30,gs,hs
 * vim:ts=8
 * vim:sw=8
 * vim:noexpandtab
 */
Revision:	1.1
Committed:	Thu Jul 19 08:24:59 2007 UTC (16 years, 10 months ago) by pippijn
Content type:	text/plain
Branch:	MAIN
Log Message:	initial import. the most important changes since Atheme are: - fixed many memory leaks - fixed many bugs - converted to C++ and use more STL containers - added a (not very enhanced yet) perl module - greatly improved XML-RPC speed - added a JSON-RPC module with code from json-cpp - added a valgrind memcheck module to operserv - added a more object oriented base64 implementation - added a specialised unit test framework - improved stability - use gettimeofday() if available - reworked adding/removing commands - MemoServ IGNORE DEL can now remove indices
#	Content
1	/*
2	* table.C: Table rendering class.
3	* Rights to this code are documented in doc/LICENSE.
4	*
5	* NOTE: This is a work in progress and will probably change considerably
6	* later on.
7	*
8	* Copyright © 2005-2007 Atheme Project (http://www.atheme.org)
9	*/
10
11	static char const rcsid[] = "$Id";
12
13	#include "atheme.h"
14
15	static void
16	table_destroy (void *obj)
17	{
18	table_t table = (table_t ) obj;
19	node_t n, tn;
20
21	return_if_fail (table != NULL);
22
23	LIST_FOREACH_SAFE (n, tn, table->rows.head)
24	{
25	table_row_t r = (table_row_t ) n->data;
26	node_t n2, tn2;
27
28	return_if_fail (r != NULL);
29
30	LIST_FOREACH_SAFE (n2, tn2, r->cells.head)
31	{
32	table_cell_t c = (table_cell_t ) n2->data;
33
34	free (c->name);
35	free (c->value);
36	free (c);
37	node_del (n2, &r->cells);
38	node_free (n2);
39	}
40
41	free (r);
42
43	node_del (n, &table->rows);
44	node_free (n);
45	}
46
47	free (table);
48	}
49
50	/*
51	* table_new(const char *fmt, ...)
52	*
53	* Table constructor.
54	*
55	* Inputs:
56	* - printf-style string to name the table with.
57	*
58	* Outputs:
59	* - a table object.
60	*
61	* Side Effects:
62	* - none
63	*/
64	table_t *
65	table_new (const char *fmt, ...)
66	{
67	va_list vl;
68	char *buf;
69	table_t *out;
70
71	return_val_if_fail (fmt != NULL, NULL);
72
73	va_start (vl, fmt);
74	vasprintf (&buf, fmt, vl);
75	va_end (vl);
76
77	out = static_cast<table_t *> (scalloc (sizeof (table_t), 1));
78	object_init (&out->parent, buf, table_destroy);
79	free (buf);
80
81	return out;
82	}
83
84	/*
85	* table_row_new
86	*
87	* Creates a table row. This isn't an object.
88	*
89	* Inputs:
90	* - table to associate to.
91	*
92	* Outputs:
93	* - a table row
94	*
95	* Side Effects:
96	* - none
97	*/
98	table_row_t *
99	table_row_new (table_t * t)
100	{
101	table_row_t *out;
102
103	return_val_if_fail (t != NULL, NULL);
104
105	out = static_cast<table_row_t *> (scalloc (sizeof (table_row_t), 1));
106
107	node_add (out, node_create (), &t->rows);
108
109	return out;
110	}
111
112	/*
113	* table_cell_associate
114	*
115	* Associates a cell with a row.
116	*
117	* Inputs:
118	* - row to add cell to.
119	*
120	* Outputs:
121	* - nothing
122	*
123	* Side Effects:
124	* - none
125	*/
126	void
127	table_cell_associate (table_row_t * r, const char name, const char value)
128	{
129	table_cell_t *c;
130
131	return_if_fail (r != NULL);
132	return_if_fail (name != NULL);
133	return_if_fail (value != NULL);
134
135	c = static_cast<table_cell_t *> (scalloc (sizeof (table_cell_t), 1));
136
137	c->name = sstrdup (name);
138	c->value = sstrdup (value);
139
140	node_add (c, node_create (), &r->cells);
141	}
142
143	/*
144	* table_render
145	*
146	* Renders a table. This is a two-pass operation, the first one to find out
147	* the width of each cell, and then the second to render the data.
148	*
149	* Inputs:
150	* - a table
151	* - a callback function
152	* - opaque data
153	*
154	* Outputs:
155	* - none
156	*
157	* Side Effects:
158	* - a callback function is called for each row of the table.
159	*/
160	void
161	table_render (table_t * t, void (callback) (const char line, void data), void data)
162	{
163	node_t *n;
164	table_row_t *f;
165	size_t bufsz = 0;
166	char *buf = NULL;
167	char *p;
168	int i;
169
170	return_if_fail (t != NULL);
171	return_if_fail (callback != NULL);
172
173	f = (table_row_t *) t->rows.head->data;
174
175	LIST_FOREACH (n, t->rows.head)
176	{
177	table_row_t r = (table_row_t ) n->data;
178	node_t n2, rn;
179
180	/* we, uhh... we don't provide a macro for dealing with two lists at once ;) */
181	for (n2 = r->cells.head, rn = f->cells.head; n2 != NULL && rn != NULL; n2 = n2->next, rn = rn->next)
182	{
183	table_cell_t c, rc;
184	size_t sz;
185
186	c = (table_cell_t *) n2->data;
187	rc = (table_cell_t *) rn->data;
188
189	if ((sz = strlen (c->name)) > (size_t) rc->width)
190	rc->width = sz;
191
192	if ((sz = strlen (c->value)) > (size_t) rc->width)
193	rc->width = sz;
194	}
195	}
196
197	/* now total up the result. */
198	LIST_FOREACH (n, f->cells.head)
199	{
200	table_cell_t c = (table_cell_t ) n->data;
201	bufsz += c->width + 1;
202	}
203
204	buf = static_cast<char *> (smalloc (bufsz));
205	*buf = '\0';
206
207	/* start outputting the header. */
208	callback (asobject (t)->name, data);
209	LIST_FOREACH (n, f->cells.head)
210	{
211	table_cell_t c = (table_cell_t ) n->data;
212	char fmtbuf[12];
213	char buf2[1024];
214
215	/* dynamically generate the format string based on width. */
216	snprintf (fmtbuf, 12, n->next != NULL ? "%%-%ds " : "%%s", c->width);
217	snprintf (buf2, 1024, fmtbuf, c->name);
218
219	strlcat (buf, buf2, bufsz);
220	}
221	callback (buf, data);
222	*buf = '\0';
223
224	/* separator line */
225	p = buf;
226	LIST_FOREACH (n, f->cells.head)
227	{
228	table_cell_t c = (table_cell_t ) n->data;
229
230	if (n->next != NULL)
231	{
232	for (i = 0; i < c->width; i++)
233	*p++ = '-';
234	*p++ = ' ';
235	}
236	else
237	for (i = 0; i < (int) strlen (c->name); i++)
238	*p++ = '-';
239	}
240	*p = '\0';
241	callback (buf, data);
242	*buf = '\0';
243
244	LIST_FOREACH (n, t->rows.head)
245	{
246	table_row_t r = (table_row_t ) n->data;
247	node_t n2, rn;
248
249	for (n2 = r->cells.head, rn = f->cells.head; n2 != NULL && rn != NULL; n2 = n2->next, rn = rn->next)
250	{
251	table_cell_t c, rc;
252	char fmtbuf[12];
253	char buf2[1024];
254
255	c = (table_cell_t *) n2->data;
256	rc = (table_cell_t *) rn->data;
257
258	/* dynamically generate the format string based on width. */
259	snprintf (fmtbuf, 12, n2->next != NULL ? "%%-%ds " : "%%s", rc->width);
260	snprintf (buf2, 1024, fmtbuf, c->value);
261
262	strlcat (buf, buf2, bufsz);
263	}
264	callback (buf, data);
265	*buf = '\0';
266	}
267
268	/* separator line */
269	p = buf;
270	LIST_FOREACH (n, f->cells.head)
271	{
272	table_cell_t c = (table_cell_t ) n->data;
273
274	if (n->next != NULL)
275	{
276	for (i = 0; i < c->width; i++)
277	*p++ = '-';
278	*p++ = ' ';
279	}
280	else
281	for (i = 0; i < (int) strlen (c->name); i++)
282	*p++ = '-';
283	}
284	*p = '\0';
285	callback (buf, data);
286	*buf = '\0';
287	}
288
289	/* vim:cinoptions=>s,e0,n0,f0,{0,}0,^0,=s,ps,t0,c3,+s,(2s,us,)20,*30,gs,hs
290	* vim:ts=8
291	* vim:sw=8
292	* vim:noexpandtab
293	*/