changed prototype of g_boxed_type_register_static() to contain an optional

Wed Mar  7 09:36:33 2001  Tim Janik  <timj@gtk.org>

	* gboxed.[hc]: changed prototype of g_boxed_type_register_static()
	to contain an optional init function and a hint at whether the
	boxed structure uses ref counting internally.
	added g_value_set_boxed_take_ownership().
	made G_TYPE_BOXED an abstract value type.

	* genums.[hc]: made G_TYPE_ENUM and G_TYPE_FLAGS abstract value
	types.

	* glib-genmarshal.c: argument type changes, preparation for third-party
	arg specification.

	* gobject.[hc]: cleaned up get/set property code.
	added g_strdup_value_contents() to improve warnings.

	* gparam.[hc]: added g_param_value_convert(), taking over responsibility
	of the old g_value_convert(). added G_PARAM_LAX_VALIDATION flag so
	validation alterations may be valid a part of the property setting
	process.

	* gparamspecs.[hc]: made value comparisons stable (for sort applications).
	added GParamSpecValueArray, a param spec for value arrays and
	GParamSpecClosure. nuked the value exchange functions and
	GParamSpecCCallback.

	* gtype.[hc]: catch unintialized usages of the type system with
	g_return_val_if_uninitialized(). introduced G_TYPE_FLAG_VALUE_ABSTRACT
	to flag types that introduce a value table, but can't be used for
	g_value_init(). cleaned up reserved type ids.

	* gvalue.[hc]: code cleanups and saner checking.
	nuked the value exchange API. implemented value transformations, we
	can't really "convert" values, rather transforms are an anylogy to
	C casts, real conversions need a param spec for validation, which is
	why g_param_value_convert() does real conversions now.

	* gvaluearray.[hc]: new files that implement a GValueArray, a struct
	that can hold inhomogeneous arrays of value (to that extend that it
	also allowes undefined values, i.e. G_VALUE_TYPE(value)==0).
	this is exposed to the type system as a boxed type.

	* gvaluetransform.c: new file implementing most of the former value
	exchange functions as single-sided transformations.

	* gvaluetypes.[hc]: nuked G_TYPE_CCALLBACK, added
	g_value_set_string_take_ownership().

	* *.h: s/G_IS_VALUE_/G_VALUE_HOLDS_/.

	* *.[hc]: many fixes and cleanups.

	* many warning improvements.

Tue Feb 27 18:35:15 2001  Tim Janik  <timj@gtk.org>

	* gobject.c (g_object_get_valist): urg, pass G_VALUE_NOCOPY_CONTENTS
	into G_VALUE_LCOPY(), this needs proper documenting.

	* gparam.c: fixed G_PARAM_USER_MASK.

	* gtype.c (type_data_make_W):
	(type_data_last_unref_Wm): fixed invalid memory freeing.

	* gobject.c (g_object_last_unref): destroy signal handlers associated
	with object, right before finalization.

	* gsignal.c (g_signal_parse_name): catch destroyed nodes or signals
	that don't actually support details.

	* gobject.[hc]: got rid of property trailers. nuked GObject
	properties "data" and the "signal" variants.
	(g_object_connect): new convenience function to do multiple
	signal connections at once.
	(g_object_disconnect): likewise, for disconnections.

	* gparam.[hc] (g_param_spec_pool_lookup): took out trailer support.

	* gvalue.[hc]: marked g_value_fits_pointer() and g_value_peek_pointer()
	as private (the latter got renamed from g_value_get_as_pointer()).

Wed Mar  7 09:32:06 2001  Tim Janik  <timj@gtk.org>

        * glib-object.h: add gvaluearray.h.

        * gstring.[hc]: fixup naming of g_string_sprint*.

        * gtypes.h: fixed GCompareDataFunc naming.

Wed Mar  7 09:33:27 2001  Tim Janik  <timj@gtk.org>

        * gobject/Makefile.am: shuffled rules to avoid excessive
        rebuilds.

        * gobject/gobject-sections.txt: updates.

        * gobject/tmpl/*: bunch of updates, added another patch
        from Eric Lemings <eric.b.lemings@lmco.com>.

1 files changed, 184 insertions, 0 deletions

diff --git a/gobject/gvaluearray.c b/gobject/gvaluearray.c
new file mode 100644
index 000000000..30bc6b9e6
--- /dev/null
+++ b/gobject/gvaluearray.c
@@ -0,0 +1,184 @@
+/* GObject - GLib Type, Object, Parameter and Signal Library
+ * Copyright (C) 2001 Red Hat, Inc.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General
+ * Public License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place, Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+/*
+ * MT safe
+ */
+
+#include	"gvaluearray.h"
+#include	<string.h>
+#include	<stdlib.h>	/* qsort() */
+
+
+
+/* --- functions --- */
+GValue*
+g_value_array_get_nth (GValueArray *value_array,
+		       guint        index)
+{
+  g_return_val_if_fail (value_array != NULL, NULL);
+  g_return_val_if_fail (index < value_array->n_values, NULL);
+
+  return value_array->values + index;
+}
+
+GValueArray*
+g_value_array_new (guint n_prealloced)
+{
+  GValueArray *value_array = g_new0 (GValueArray, 1);
+
+  value_array->n_values = n_prealloced;
+  value_array->values = g_renew (GValue, value_array->values, value_array->n_values);
+  memset (value_array->values, 0, value_array->n_values * sizeof (value_array->values[0]));
+
+  return value_array;
+}
+
+void
+g_value_array_free (GValueArray *value_array)
+{
+  guint i;
+
+  g_return_if_fail (value_array != NULL);
+
+  for (i = 0; i < value_array->n_values; i++)
+    {
+      GValue *value = value_array->values + i;
+
+      if (G_VALUE_TYPE (value) != 0) /* we allow unset values in the array */
+	g_value_unset (value);
+    }
+  g_free (value_array->values);
+  g_free (value_array);
+}
+
+GValueArray*
+g_value_array_copy (const GValueArray *value_array)
+{
+  GValueArray *new_array;
+  guint i;
+
+  g_return_val_if_fail (value_array != NULL, NULL);
+
+  new_array = g_new0 (GValueArray, 1);
+  new_array->n_values = value_array->n_values;
+  new_array->values = g_renew (GValue, new_array->values, new_array->n_values);
+  memset (new_array->values, 0, new_array->n_values * sizeof (new_array->values[0]));
+  for (i = 0; i < new_array->n_values; i++)
+    if (G_VALUE_TYPE (value_array->values + i) != 0)
+      {
+	GValue *value = new_array->values + i;
+	
+	g_value_init (value, G_VALUE_TYPE (value_array->values + i));
+	g_value_copy (value_array->values + i, value);
+      }
+  return new_array;
+}
+
+GValueArray*
+g_value_array_prepend (GValueArray  *value_array,
+		       const GValue *value)
+{
+  g_return_val_if_fail (value_array != NULL, NULL);
+
+  return g_value_array_insert (value_array, 0, value);
+}
+
+GValueArray*
+g_value_array_append (GValueArray  *value_array,
+		      const GValue *value)
+{
+  g_return_val_if_fail (value_array != NULL, NULL);
+
+  return g_value_array_insert (value_array, value_array->n_values, value);
+}
+
+GValueArray*
+g_value_array_insert (GValueArray  *value_array,
+		      guint         index,
+		      const GValue *value)
+{
+  guint i;
+
+  g_return_val_if_fail (value_array != NULL, NULL);
+  g_return_val_if_fail (index <= value_array->n_values, value_array);
+
+  /* we support NULL for "value" as a shortcut for an unset value */
+
+  i = value_array->n_values++;
+  value_array->values = g_renew (GValue, value_array->values, value_array->n_values);
+  if (index + 1 < value_array->n_values)
+    g_memmove (value_array->values + index + 1, value_array->values + index,
+	       (i - index) * sizeof (value_array->values[0]));
+  memset (value_array->values + index, 0, sizeof (value_array->values[0]));
+  if (value)
+    {
+      g_value_init (value_array->values + index, G_VALUE_TYPE (value));
+      g_value_copy (value, value_array->values + index);
+    }
+  return value_array;
+}
+
+GValueArray*
+g_value_array_remove (GValueArray *value_array,
+		      guint        index)
+{
+  g_return_val_if_fail (value_array != NULL, NULL);
+  g_return_val_if_fail (index < value_array->n_values, value_array);
+
+  if (G_VALUE_TYPE (value_array->values + index) != 0)
+    g_value_unset (value_array->values + index);
+  value_array->n_values--;
+  if (index < value_array->n_values)
+    g_memmove (value_array->values + index, value_array->values + index + 1,
+	       (value_array->n_values - index) * sizeof (value_array->values[0]));
+  value_array->values = g_renew (GValue, value_array->values, value_array->n_values);
+
+  return value_array;
+}
+
+GValueArray*
+g_value_array_sort (GValueArray *value_array,
+		    GCompareFunc compare_func)
+{
+  g_return_val_if_fail (compare_func != NULL, NULL);
+
+  if (value_array->n_values)
+    qsort (value_array->values,
+	   value_array->n_values,
+	   sizeof (value_array->values[0]),
+	   compare_func);
+  return value_array;
+}
+
+GValueArray*
+g_value_array_sort_with_data (GValueArray     *value_array,
+			      GCompareDataFunc compare_func,
+			      gpointer         user_data)
+{
+  g_return_val_if_fail (value_array != NULL, NULL);
+  g_return_val_if_fail (compare_func != NULL, NULL);
+
+  if (value_array->n_values)
+    g_qsort_with_data (value_array->values,
+		       value_array->n_values,
+		       sizeof (value_array->values[0]),
+		       compare_func, user_data);
+  return value_array;
+}