/* This is -*- C -*- */ /* $Id: guppi-seq-boolean.c,v 1.26 2002/01/14 05:01:17 trow Exp $ */ /* * guppi-seq-boolean.c * * Copyright (C) 2000 EMC Capital Management, Inc. * Copyright (C) 2001 The Free Software Foundation * * Developed by Jon Trowbridge and * Havoc Pennington . * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License as * published by the Free Software Foundation; either version 2 of the * License, or (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 * USA */ #include #include "guppi-seq-boolean.h" /* #include */ #include #include #include #include #include static GtkObjectClass *parent_class = NULL; static void guppi_seq_boolean_finalize (GtkObject * obj) { if (parent_class->finalize) parent_class->finalize (obj); } static xmlNodePtr export_xml_element (GuppiSeq *seq, gint i, GuppiXMLDocument *doc) { gboolean x = guppi_seq_boolean_get (GUPPI_SEQ_BOOLEAN (seq), i); return xmlNewNode (doc->ns, x ? "true" : "false"); } static gboolean import_xml_element (GuppiSeq *seq, GuppiXMLDocument *doc, xmlNodePtr node) { if (!strcmp (node->name, "true")) guppi_seq_boolean_append ((GuppiSeqBoolean *) seq, TRUE); else if (!strcmp (node->name, "false")) guppi_seq_boolean_append ((GuppiSeqBoolean *) seq, FALSE); else { g_warning ("Bad boolean node: \"%s\"", node->name); return FALSE; } return TRUE; } /***************************************************************************/ typedef struct _GuppiDataOp_Boolean GuppiDataOp_Boolean; struct _GuppiDataOp_Boolean { GuppiDataOp op; gint i; gsize N; gboolean x; const gint *iptr; const GuppiSeqBoolean *other; }; static void op_set (GuppiData *d, GuppiDataOp *op) { GuppiDataOp_Boolean *bop = (GuppiDataOp_Boolean *) op; GuppiSeqBoolean *seq; GuppiSeqBooleanClass *klass; seq = GUPPI_SEQ_BOOLEAN (d); klass = GUPPI_SEQ_BOOLEAN_CLASS (GTK_OBJECT (d)->klass); g_assert (klass->set); klass->set (seq, bop->i, bop->x); } static void op_set_all (GuppiData *d, GuppiDataOp *op) { GuppiDataOp_Boolean *bop = (GuppiDataOp_Boolean *) op; GuppiSeqBoolean *seq; GuppiSeqBooleanClass *klass; seq = GUPPI_SEQ_BOOLEAN (d); klass = GUPPI_SEQ_BOOLEAN_CLASS (GTK_OBJECT (d)->klass); g_assert (klass->set_all); klass->set_all (seq, bop->x); } static void op_set_many (GuppiData *d, GuppiDataOp *op) { GuppiDataOp_Boolean *bop = (GuppiDataOp_Boolean *) op; GuppiSeqBoolean *seq; GuppiSeqBooleanClass *klass; seq = GUPPI_SEQ_BOOLEAN (d); klass = GUPPI_SEQ_BOOLEAN_CLASS (GTK_OBJECT (d)->klass); if (klass->set_many) { klass->set_many (seq, bop->iptr, bop->N, bop->x); } else { gint i = 0, i0, i1; guppi_seq_bounds (GUPPI_SEQ (d), &i0, &i1); g_assert (klass->set); for (i = 0; i < bop->N; ++i) { gint j = bop->iptr[i]; if (i0 <= j && j <= i1) klass->set (seq, j, bop->x); } } /* FIXME missing values! */ } static void op_insert (GuppiData *d, GuppiDataOp *op) { GuppiDataOp_Boolean *bop = (GuppiDataOp_Boolean *) op; GuppiSeqBoolean *seq; GuppiSeqBooleanClass *klass; seq = GUPPI_SEQ_BOOLEAN (d); klass = GUPPI_SEQ_BOOLEAN_CLASS (GTK_OBJECT (d)->klass); if (klass->insert) klass->insert (seq, bop->i, bop->x); else if (klass->insert_many) klass->insert_many (seq, bop->i, bop->x, 1); else g_assert_not_reached (); } static void op_insert_many (GuppiData *d, GuppiDataOp *op) { GuppiDataOp_Boolean *bop = (GuppiDataOp_Boolean *) op; GuppiSeqBoolean *seq; GuppiSeqBooleanClass *klass; seq = GUPPI_SEQ_BOOLEAN (d); klass = GUPPI_SEQ_BOOLEAN_CLASS (GTK_OBJECT (d)->klass); g_assert (klass->insert_many); klass->insert_many (seq, bop->i, bop->x, bop->N); } static void op_and (GuppiData *d, GuppiDataOp *op) { GuppiDataOp_Boolean *bop = (GuppiDataOp_Boolean *) op; GuppiSeqBoolean *seq; GuppiSeqBoolean *other_seq; GuppiSeqBooleanClass *klass; seq = GUPPI_SEQ_BOOLEAN (d); klass = GUPPI_SEQ_BOOLEAN_CLASS (GTK_OBJECT (d)->klass); other_seq = GUPPI_SEQ_BOOLEAN (bop->other); g_assert (klass->bitwise_and); klass->bitwise_and (seq, other_seq); } static void op_or (GuppiData *d, GuppiDataOp *op) { GuppiDataOp_Boolean *bop = (GuppiDataOp_Boolean *) op; GuppiSeqBoolean *seq; GuppiSeqBoolean *other_seq; GuppiSeqBooleanClass *klass; seq = GUPPI_SEQ_BOOLEAN (d); klass = GUPPI_SEQ_BOOLEAN_CLASS (GTK_OBJECT (d)->klass); other_seq = GUPPI_SEQ_BOOLEAN (bop->other); g_assert (klass->bitwise_or); klass->bitwise_or (seq, other_seq); } static void op_xor (GuppiData *d, GuppiDataOp *op) { GuppiDataOp_Boolean *bop = (GuppiDataOp_Boolean *) op; GuppiSeqBoolean *seq; GuppiSeqBoolean *other_seq; GuppiSeqBooleanClass *klass; seq = GUPPI_SEQ_BOOLEAN (d); klass = GUPPI_SEQ_BOOLEAN_CLASS (GTK_OBJECT (d)->klass); other_seq = GUPPI_SEQ_BOOLEAN (bop->other); g_assert (klass->bitwise_xor); klass->bitwise_xor (seq, other_seq); } static void op_not (GuppiData *d, GuppiDataOp *op) { GuppiSeqBoolean *seq; GuppiSeqBooleanClass *klass; seq = GUPPI_SEQ_BOOLEAN (d); klass = GUPPI_SEQ_BOOLEAN_CLASS (GTK_OBJECT (d)->klass); g_assert (klass->bitwise_not); klass->bitwise_not (seq); } /* ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** */ /* Default implementations, mostly to deal with missing values. */ static void v_set (GuppiSeqBoolean *sb, gint i, gboolean x) { GUPPI_SEQ_CLASS (GTK_OBJECT (sb)->klass)->set_missing (GUPPI_SEQ (sb), i, FALSE); } static void v_set_all (GuppiSeqBoolean *sb, gboolean x) { GUPPI_SEQ_CLASS (GTK_OBJECT (sb)->klass)->set_all_missing (GUPPI_SEQ (sb), FALSE); } static void v_set_many (GuppiSeqBoolean *sb, const gint *indices, gsize N, gboolean x) { GuppiSeqClass *seq_class = GUPPI_SEQ_CLASS (GTK_OBJECT (sb)->klass); GuppiSeq *seq = GUPPI_SEQ (sb); gint i; /* This is a candidate for obvious optimization */ for (i = 0; i < (gint) N; ++i) { seq_class->set_missing (seq, indices[i], FALSE); } } static void v_insert (GuppiSeqBoolean *sb, gint i, gboolean x) { GUPPI_SEQ_CLASS (GTK_OBJECT (sb)->klass)->insert_missing (GUPPI_SEQ (sb), i, FALSE, 1); } static void v_insert_many (GuppiSeqBoolean *sb, gint i, gboolean x, gsize N) { GUPPI_SEQ_CLASS (GTK_OBJECT (sb)->klass)->insert_missing (GUPPI_SEQ (sb), i, FALSE, N); } /* ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** */ #if 0 /** * guppi_seq_boolean_new_aligned * @seq: A sequence * * Allocates a new boolean sequence whose index bounds are the same as @seq. * All the elements of the new sequence are initially set to %FALSE. * A default implementation is used. * * Returns: The newly-allocated sequence */ GuppiData * guppi_seq_boolean_new_aligned (const GuppiSeq *seq) { GuppiSeqBoolean *aligned; if (seq == NULL) return NULL; aligned = GUPPI_SEQ_BOOLEAN (guppi_seq_boolean_new ()); guppi_seq_boolean_append_many (aligned, FALSE, guppi_seq_size (seq)); guppi_seq_set_min_index (GUPPI_SEQ (aligned), guppi_seq_min_index (seq)); return GUPPI_DATA (aligned); } #endif /** * guppi_seq_boolean_get * @seq: A boolean sequence * @i: A position index * * Returns: The boolean value of the @i-th element of @seq. * @i must lie within @seq's bounds. */ gboolean guppi_seq_boolean_get (const GuppiSeqBoolean *seq, gint i) { GuppiSeqBooleanClass *klass; g_return_val_if_fail (seq != NULL, FALSE); g_return_val_if_fail (guppi_seq_in_bounds (GUPPI_SEQ (seq), i), FALSE); klass = GUPPI_SEQ_BOOLEAN_CLASS (GTK_OBJECT (seq)->klass); g_assert (klass->get); return klass->get ((GuppiSeqBoolean *) seq, i); } /** * guppi_seq_boolean_set * @seq: A boolean sequence * @i: A position impl * @x: A boolean value * * Sets the @i-th element of the sequence @seq to @x. * @seq must be writeable, and @i must lie within @seq's bounds. */ void guppi_seq_boolean_set (GuppiSeqBoolean *seq, gint i, gboolean x) { g_return_if_fail (seq != NULL && GUPPI_IS_SEQ_BOOLEAN (seq)); g_return_if_fail (guppi_data_can_change (GUPPI_DATA (seq))); g_return_if_fail (guppi_seq_in_bounds (GUPPI_SEQ (seq), i)); if (guppi_seq_boolean_get (seq, i) != x) { GuppiDataOp_Boolean op; op.op.op = op_set; op.i = i; op.x = x; guppi_seq_changed_set (GUPPI_SEQ (seq), i, i, (GuppiDataOp *) & op); } } /** * guppi_seq_boolean_set_all * @seq: A boolean sequence * @x: A boolean value * * Sets all of the elements of @seq to @x. */ void guppi_seq_boolean_set_all (GuppiSeqBoolean *seq, gboolean x) { GuppiDataOp_Boolean op; gint i0, i1; g_return_if_fail (seq != NULL && GUPPI_IS_SEQ_BOOLEAN (seq)); g_return_if_fail (guppi_data_can_change (GUPPI_DATA (seq))); guppi_seq_bounds (GUPPI_SEQ (seq), &i0, &i1); op.op.op = op_set_all; op.x = x; guppi_seq_changed_set (GUPPI_SEQ (seq), i0, i1, (GuppiDataOp *) & op); } /** * guppi_seq_boolean_set_many * @seq: A boolean sequence * @indices: An array of position indices * @N: The length of array @indices * @x: A boolean value * * Iterates across the array @indices, reading the position indices * contained in that array and setting the corresponding entries of * @seq equal to @x. */ void guppi_seq_boolean_set_many (GuppiSeqBoolean *seq, gint *indices, gsize N, gboolean x) { GuppiDataOp_Boolean op; gint i, i0, i1; g_return_if_fail (seq != NULL && GUPPI_IS_SEQ_BOOLEAN (seq)); g_return_if_fail (guppi_data_can_change (GUPPI_DATA (seq))); if (N == 0) return; g_return_if_fail (indices != NULL); i0 = i1 = indices[0]; for (i = 1; i < N; ++i) { if (indices[i] < i0) i0 = indices[i]; if (indices[i] > i1) i1 = indices[i]; } op.op.op = op_set_many; op.iptr = indices; op.N = N; op.x = x; guppi_seq_changed_set (GUPPI_SEQ (seq), i0, i1, (GuppiDataOp *) & op); } /** * guppi_seq_boolean_clear * @seq: A boolean sequence * * Set all of the elements of @seq equal to %FALSE. */ void guppi_seq_boolean_clear (GuppiSeqBoolean *seq) { guppi_seq_boolean_set_all (seq, FALSE); } /** * guppi_seq_boolean_prepend * @seq: A boolean sequence * @x: A boolean value * * Prepend the boolean value @x to the sequence @seq. * @seq must be writeable. */ void guppi_seq_boolean_prepend (GuppiSeqBoolean *seq, gboolean x) { gint i; g_return_if_fail (seq != NULL); g_return_if_fail (guppi_data_can_change (GUPPI_DATA (seq))); i = guppi_seq_min_index (GUPPI_SEQ (seq)); guppi_seq_boolean_insert (seq, i, x); } /** * guppi_seq_boolean_prepend_many * @seq: A boolean sequence * @x: A boolean value * @N: A count * * Prepend @N instances of the boolean value @x to the sequence @seq. * @seq must be writeable. */ void guppi_seq_boolean_prepend_many (GuppiSeqBoolean *seq, gboolean x, gsize N) { gint i; g_return_if_fail (seq != NULL); g_return_if_fail (guppi_data_can_change (GUPPI_DATA (seq))); if (N == 0) return; i = guppi_seq_min_index (GUPPI_SEQ (seq)); guppi_seq_boolean_insert_many (seq, i, x, N); } /** * guppi_seq_boolean_append * @seq: A boolean sequence * @x: A boolean value * * Append the boolean value @x to the sequence @seq. * @seq must be writeable. */ void guppi_seq_boolean_append (GuppiSeqBoolean *seq, gboolean x) { gint i; g_return_if_fail (seq != NULL); g_return_if_fail (guppi_data_can_change (GUPPI_DATA (seq))); i = guppi_seq_max_index (GUPPI_SEQ (seq)); guppi_seq_boolean_insert (seq, i + 1, x); } /** * guppi_seq_boolean_append_many * @seq: A boolean sequence * @x: A boolean value * @N: A count * * Append @N instances of the boolean value @x to the sequence @seq. * @seq must be writeable. */ void guppi_seq_boolean_append_many (GuppiSeqBoolean *seq, gboolean x, gsize N) { gint i; g_return_if_fail (seq != NULL); g_return_if_fail (guppi_data_can_change (GUPPI_DATA (seq))); if (N == 0) return; i = guppi_seq_max_index (GUPPI_SEQ (seq)); guppi_seq_boolean_insert_many (seq, i + 1, x, N); } /** * guppi_seq_boolean_insert * @seq: A boolean sequence * @i: A position index * @x: A boolean value * * Insert the boolean value @x into the sequence @seq at position @i. * @seq must be writeable. */ void guppi_seq_boolean_insert (GuppiSeqBoolean *seq, gint i, gboolean x) { GuppiDataOp_Boolean op; g_return_if_fail (seq != NULL && GUPPI_IS_SEQ_BOOLEAN (seq)); g_return_if_fail (guppi_data_can_change (GUPPI_DATA (seq))); op.op.op = op_insert; op.i = i; op.x = x; guppi_seq_changed_insert (GUPPI_SEQ (seq), i, i, (GuppiDataOp *) & op); } /** * guppi_seq_boolean_insert_many * @seq: A boolean sequence * @i: A position index * @x: A boolean value * @N: A count * * Insert @N instances of the boolean value @x into the sequence @seq * at position @i. * @seq must be writeable. */ void guppi_seq_boolean_insert_many (GuppiSeqBoolean *seq, gint i, gboolean x, gsize N) { GuppiDataOp_Boolean op; g_return_if_fail (seq != NULL && GUPPI_IS_SEQ_BOOLEAN (seq)); g_return_if_fail (guppi_data_can_change (GUPPI_DATA (seq))); if (N == 0) return; op.op.op = op_insert_many; op.i = i; op.x = x; op.N = N; guppi_seq_changed_insert (GUPPI_SEQ (seq), i, N, (GuppiDataOp *) & op); } /** * guppi_seq_boolean_bitwise_and * @seq: A boolean sequence * @other: Another boolean sequence * * Set each element of @seq equal to the logical AND of that * element and the corresponding element in @other. * Only the section of @seq whose indices overlap those of @other * are affected. * @seq must be writeable. */ void guppi_seq_boolean_bitwise_and (GuppiSeqBoolean *seq, const GuppiSeqBoolean *other) { GuppiDataOp_Boolean op; gint i0, i1; g_return_if_fail (seq != NULL && GUPPI_IS_SEQ_BOOLEAN (seq)); g_return_if_fail (guppi_data_can_change (GUPPI_DATA (seq))); guppi_seq_common_bounds (GUPPI_SEQ (seq), GUPPI_SEQ (other), &i0, &i1); op.op.op = op_and; op.other = other; guppi_seq_changed_set (GUPPI_SEQ (seq), i0, i1, (GuppiDataOp *) & op); } /** * guppi_seq_boolean_bitwise_or * @seq: A boolean sequence * @other: Another boolean sequence * * Set each element of @seq equal to the logical %OR of that * element and the corresponding element in @other. * Only the section of @seq whose indices overlap those of @other * are affected. * @seq must be writeable. */ void guppi_seq_boolean_bitwise_or (GuppiSeqBoolean *seq, const GuppiSeqBoolean *other) { GuppiDataOp_Boolean op; gint i0, i1; g_return_if_fail (seq != NULL && GUPPI_IS_SEQ_BOOLEAN (seq)); g_return_if_fail (guppi_data_can_change (GUPPI_DATA (seq))); guppi_seq_common_bounds (GUPPI_SEQ (seq), GUPPI_SEQ (other), &i0, &i1); op.op.op = op_or; op.other = other; guppi_seq_changed_set (GUPPI_SEQ (seq), i0, i1, (GuppiDataOp *) & op); } /** * guppi_seq_boolean_bitwise_xor * @seq: A boolean sequence * @other: Another boolean sequence * * Set each element of @seq equal to the logical %XOR of that * element and the corresponding element in @other. * Only the section of @seq whose indices overlap those of @other * are affected. * @seq must be writeable. */ void guppi_seq_boolean_bitwise_xor (GuppiSeqBoolean *seq, const GuppiSeqBoolean *other) { GuppiDataOp_Boolean op; gint i0, i1; g_return_if_fail (seq != NULL && GUPPI_IS_SEQ_BOOLEAN (seq)); g_return_if_fail (guppi_data_can_change (GUPPI_DATA (seq))); guppi_seq_common_bounds (GUPPI_SEQ (seq), GUPPI_SEQ (other), &i0, &i1); op.op.op = op_xor; op.other = other; guppi_seq_changed_set (GUPPI_SEQ (seq), i0, i1, (GuppiDataOp *) & op); } /** * guppi_seq_boolean_bitwise_not * @seq: A boolean sequence * * Set each element of @seq equal to the logical %NOT of that * element. * @seq must be writeable. */ void guppi_seq_boolean_bitwise_not (GuppiSeqBoolean *seq) { GuppiDataOp_Boolean op; gint i0, i1; g_return_if_fail (seq != NULL && GUPPI_IS_SEQ_BOOLEAN (seq)); g_return_if_fail (guppi_data_can_change (GUPPI_DATA (seq))); guppi_seq_bounds (GUPPI_SEQ (seq), &i0, &i1); op.op.op = op_not; guppi_seq_changed_set (GUPPI_SEQ (seq), i0, i1, (GuppiDataOp *) & op); } /** * guppi_seq_boolean_first_true * @seq: A boolean sequence * * Finds the first %TRUE element of @seq. If @seq contains only * %FALSE values, an out-of-bounds index is returned. * * Returns: The index of the lowest-numbered position in @seq * whose value is %TRUE. */ gint guppi_seq_boolean_first_true (const GuppiSeqBoolean *seq) { GuppiSeqBooleanClass *klass; gint i, i0, i1; g_return_val_if_fail (seq != NULL, 1); klass = GUPPI_SEQ_BOOLEAN_CLASS (GTK_OBJECT (seq)->klass); i0 = guppi_seq_min_index (GUPPI_SEQ (seq)); if (klass->next_true) { return klass->next_true ((GuppiSeqBoolean *) seq, i0 - 1); } g_assert (klass->get); i1 = guppi_seq_max_index (GUPPI_SEQ (seq)); for (i = i0; i <= i1 && klass->get ((GuppiSeqBoolean *) seq, i); ++i); return i; } /** * guppi_seq_boolean_next_true * @seq: A boolean sequence * @i: A position index * * Finds the first %TRUE element of @seq whose index is greater * that @i. If no such element exists, an out-of-bounds index * value is returned. * * Returns: The index of the next %TRUE value in @seq. */ gint guppi_seq_boolean_next_true (const GuppiSeqBoolean *seq, gint i) { GuppiSeqBooleanClass *klass; gint i1; g_return_val_if_fail (seq != NULL, 1); klass = GUPPI_SEQ_BOOLEAN_CLASS (GTK_OBJECT (seq)->klass); i1 = guppi_seq_max_index (GUPPI_SEQ (seq)); if (i1 < i) return i; if (klass->next_true) { return klass->next_true ((GuppiSeqBoolean *) seq, i); } g_assert (klass->get); while (i < i1) { ++i; if (klass->get ((GuppiSeqBoolean *) seq, i)) return i; } return i; } /** * guppi_seq_boolean_first_jointly_true * @a: A boolean sequence * @b: Another boolean sequence * * Finds the lowest-valued index value which is common to * both @a and @b, and for which both sequences contain %TRUE. * If no such element exists, an out-of-bounds index is * returned. * * Returns: The index of the lowest-numbered position * whose value is %TRUE for both @a and @b. */ gint guppi_seq_boolean_first_jointly_true (const GuppiSeqBoolean *a, const GuppiSeqBoolean *b) { gint i, i0, i1; g_return_val_if_fail (GUPPI_IS_SEQ_BOOLEAN (a), 0); g_return_val_if_fail (GUPPI_IS_SEQ_BOOLEAN (b), 0); guppi_seq_common_bounds (GUPPI_SEQ (a), GUPPI_SEQ (b), &i0, &i1); i = i0; if (!guppi_seq_boolean_get (a, i)) i = guppi_seq_boolean_next_true (a, i); while (i <= i1 && !guppi_seq_boolean_get (b, i)) i = guppi_seq_boolean_next_true (a, i); return i; } /** * guppi_seq_boolean_next_jointly_true * @a: A boolean sequences * @b: Another boolean sequences * @i: A position index * * Finds the index value of the next element beyond index @i which is * %TRUE for both @a and @b. If no such element exists, an out-of-bounds * value is returned. * * Returns: The next index value that is %TRUE for both @a and @b. */ gint guppi_seq_boolean_next_jointly_true (const GuppiSeqBoolean *a, const GuppiSeqBoolean *b, gint i) { gint i0, i1; gint ia, ib; g_return_val_if_fail (GUPPI_IS_SEQ_BOOLEAN (a), 0); g_return_val_if_fail (GUPPI_IS_SEQ_BOOLEAN (b), 0); guppi_seq_common_bounds (GUPPI_SEQ (a), GUPPI_SEQ (b), &i0, &i1); while (i <= i1) { ia = guppi_seq_boolean_next_true (a, i); ib = guppi_seq_boolean_next_true (b, i); if (ia <= i1 && ib <= i1) { if (ia == ib) return ia; else if (ia < ib && guppi_seq_boolean_get (a, ib)) return ib; else if (ia > ib && guppi_seq_boolean_get (b, ia)) return ia; } i = MAX (ia, ib); } return i; } /** * guppi_seq_boolean_true_count * @seq: A boolean sequences * * Returns: The number of elements of the sequence @seq * that are equal to %TRUE. */ gsize guppi_seq_boolean_true_count (const GuppiSeqBoolean *seq) { GuppiSeqBooleanClass *klass; gint i, i0, i1; gsize count = 0; g_return_val_if_fail (seq != NULL, 0); klass = GUPPI_SEQ_BOOLEAN_CLASS (GTK_OBJECT (seq)->klass); if (klass->true_count) { return klass->true_count ((GuppiSeqBoolean *) seq); } g_assert (klass->get); guppi_seq_indices (GUPPI_SEQ (seq), &i0, &i1); for (i = i0; i <= i1; ++i) { if (klass->get ((GuppiSeqBoolean *) seq, i)) ++count; } return count; } /* ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** */ static void guppi_seq_boolean_class_init (GuppiSeqBooleanClass *klass) { GtkObjectClass *object_class = (GtkObjectClass *) klass; GuppiSeqClass *seq_class = GUPPI_SEQ_CLASS (klass); parent_class = gtk_type_class (GUPPI_TYPE_SEQ); klass->set = v_set; klass->set_all = v_set_all; klass->set_many = v_set_many; klass->insert = v_insert; klass->insert_many = v_insert_many; seq_class->export_xml_element = export_xml_element; seq_class->import_xml_element = import_xml_element; object_class->finalize = guppi_seq_boolean_finalize; } static void guppi_seq_boolean_init (GuppiSeqBoolean * obj) { } GtkType guppi_seq_boolean_get_type (void) { static GtkType guppi_seq_boolean_type = 0; if (!guppi_seq_boolean_type) { static const GtkTypeInfo guppi_seq_boolean_info = { "GuppiSeqBoolean", sizeof (GuppiSeqBoolean), sizeof (GuppiSeqBooleanClass), (GtkClassInitFunc) guppi_seq_boolean_class_init, (GtkObjectInitFunc) guppi_seq_boolean_init, NULL, NULL, (GtkClassInitFunc) NULL }; guppi_seq_boolean_type = gtk_type_unique (GUPPI_TYPE_SEQ, &guppi_seq_boolean_info); } return guppi_seq_boolean_type; } /* $Id: guppi-seq-boolean.c,v 1.26 2002/01/14 05:01:17 trow Exp $ */