GNOME.org
 

[aravis/error] genicam: error handling WIP.

commit 594ba763be6970d874237c1072b3fa1aeba04bde
Author: Emmanuel Pacaud <emmanuel gnome org>
Date:   Mon May 7 20:49:50 2012 +0200

    genicam: error handling WIP.

 src/arvgcconverter.c |  158 +++++++++++++++++++++++++++++++++++++++-----------
 src/arvgcfloat.c     |   48 +++++++++------
 src/arvgcfloat.h     |    8 +-
 src/arvgcinteger.c   |   42 ++++++++-----
 src/arvgcinteger.h   |    4 +-
 src/arvgcport.c      |    6 +-
 src/arvgcregister.c  |   20 ++++---
 src/arvgcstring.c    |   15 +++--
 8 files changed, 208 insertions(+), 93 deletions(-)
---
diff --git a/src/arvgcconverter.c b/src/arvgcconverter.c
index 766d517..9731eef 100644
--- a/src/arvgcconverter.c
+++ b/src/arvgcconverter.c
@@ -162,110 +162,194 @@ arv_gc_converter_class_init (ArvGcConverterClass *this_class)
 /* ArvGcInteger interface implementation */
 
 static void
-_update_from_variables (ArvGcConverter *gc_converter)
+_update_from_variables (ArvGcConverter *gc_converter, GError **error)
 {
 	ArvGcNode *node = NULL;
+	GError *local_error = NULL;
 	GSList *iter;
 	const char *expression;
 
 	if (gc_converter->formula_from_node != NULL)
-		expression = arv_gc_property_node_get_string (gc_converter->formula_from_node);
+		expression = arv_gc_property_node_get_string (gc_converter->formula_from_node, &local_error);
 	else
 		expression = "";
+
+	if (local_error != NULL) {
+		g_propagate_error (error, local_error);
+		return;
+	}
+
 	arv_evaluator_set_expression (gc_converter->formula_from, expression);
 
 	for (iter = gc_converter->variables; iter != NULL; iter = iter->next) {
 		ArvGcVariableNode *variable_node = iter->data;
 
 		node = arv_gc_property_node_get_linked_node (ARV_GC_PROPERTY_NODE (variable_node));
-		if (arv_gc_feature_node_get_value_type (ARV_GC_FEATURE_NODE (node)) == G_TYPE_INT64)
+		if (arv_gc_feature_node_get_value_type (ARV_GC_FEATURE_NODE (node)) == G_TYPE_INT64) {
+			gint64 value;
+
+			value = arv_gc_integer_get_value (ARV_GC_INTEGER (node), &local_error);
+
+			if (local_error != NULL) {
+				g_propagate_error (error, local_error);
+				return;
+			}
+
 			arv_evaluator_set_int64_variable (gc_converter->formula_from,
 							  arv_gc_variable_node_get_name (variable_node),
-							  arv_gc_integer_get_value (ARV_GC_INTEGER (node)));
-		else if (arv_gc_feature_node_get_value_type (ARV_GC_FEATURE_NODE (node)) == G_TYPE_DOUBLE)
+							  value);
+		} else if (arv_gc_feature_node_get_value_type (ARV_GC_FEATURE_NODE (node)) == G_TYPE_DOUBLE) {
+			double value;
+
+			value =  arv_gc_float_get_value (ARV_GC_FLOAT (node), &local_error);
+
+			if (local_error != NULL) {
+				g_propagate_error (error, local_error);
+				return;
+			}
+
 			arv_evaluator_set_double_variable (gc_converter->formula_from,
 							  arv_gc_variable_node_get_name (variable_node),
-							   arv_gc_float_get_value (ARV_GC_FLOAT (node)));
+							  value);
+		}
 	}
 
 	if (gc_converter->value != NULL) {
 		node = arv_gc_property_node_get_linked_node (gc_converter->value);
 
-		if (arv_gc_feature_node_get_value_type (ARV_GC_FEATURE_NODE (node)) == G_TYPE_INT64)
-			arv_evaluator_set_int64_variable (gc_converter->formula_from,
-							  "TO",
-							  arv_gc_integer_get_value (ARV_GC_INTEGER (node)));
-		else if (arv_gc_feature_node_get_value_type (ARV_GC_FEATURE_NODE (node)) == G_TYPE_DOUBLE)
-			arv_evaluator_set_double_variable (gc_converter->formula_from,
-							   "TO",
-							   arv_gc_float_get_value (ARV_GC_FLOAT (node)));
-		else
+		if (arv_gc_feature_node_get_value_type (ARV_GC_FEATURE_NODE (node)) == G_TYPE_INT64) {
+			gint64 value;
+
+			value = arv_gc_integer_get_value (ARV_GC_INTEGER (node), &local_error);
+
+			if (local_error != NULL) {
+				g_propagate_error (error, local_error);
+				return;
+			}
+
+			arv_evaluator_set_int64_variable (gc_converter->formula_from, "TO", value);
+		} else if (arv_gc_feature_node_get_value_type (ARV_GC_FEATURE_NODE (node)) == G_TYPE_DOUBLE) {
+			double value;
+
+			value = arv_gc_float_get_value (ARV_GC_FLOAT (node), &local_error);
+
+			if (local_error != NULL) {
+				g_propagate_error (error, local_error);
+				return;
+			}
+
+			arv_evaluator_set_double_variable (gc_converter->formula_from, "TO", value);
+		} else
 			arv_warning_genicam ("[GcConverter::set_value] Invalid pValue node '%s'",
 					     gc_converter->value);
 	}
 }
 
 static void
-_update_to_variables (ArvGcConverter *gc_converter)
+_update_to_variables (ArvGcConverter *gc_converter, GError **error)
 {
 	ArvGcNode *node;
+	GError *local_error = NULL;
 	GSList *iter;
 	const char *expression;
 
 	if (gc_converter->formula_to_node != NULL)
-		expression = arv_gc_property_node_get_string (gc_converter->formula_to_node);
+		expression = arv_gc_property_node_get_string (gc_converter->formula_to_node, &local_error);
 	else
 		expression = "";
+
+	if (local_error != NULL) {
+		g_propagate_error (error, local_error);
+		return;
+	}
+
 	arv_evaluator_set_expression (gc_converter->formula_to, expression);
 
 	for (iter = gc_converter->variables; iter != NULL; iter = iter->next) {
 		ArvGcVariableNode *variable_node = iter->data;
 
 		node = arv_gc_property_node_get_linked_node (ARV_GC_PROPERTY_NODE (variable_node));
-		if (arv_gc_feature_node_get_value_type (ARV_GC_FEATURE_NODE (node)) == G_TYPE_INT64)
+		if (arv_gc_feature_node_get_value_type (ARV_GC_FEATURE_NODE (node)) == G_TYPE_INT64) {
+			gint64 value;
+
+			value = arv_gc_integer_get_value (ARV_GC_INTEGER (node), &local_error);
+
+			if (local_error != NULL) {
+				g_propagate_error (error, local_error);
+				return;
+			}
+
 			arv_evaluator_set_int64_variable (gc_converter->formula_to,
 							  arv_gc_variable_node_get_name (variable_node),
-							  arv_gc_integer_get_value (ARV_GC_INTEGER (node)));
-		else if (arv_gc_feature_node_get_value_type (ARV_GC_FEATURE_NODE (node)) == G_TYPE_DOUBLE)
+							  value);
+		} else if (arv_gc_feature_node_get_value_type (ARV_GC_FEATURE_NODE (node)) == G_TYPE_DOUBLE) {
+			double value;
+
+			value =  arv_gc_float_get_value (ARV_GC_FLOAT (node), &local_error);
+
+			if (local_error != NULL) {
+				g_propagate_error (error, local_error);
+				return;
+			}
+
 			arv_evaluator_set_double_variable (gc_converter->formula_to,
 							  arv_gc_variable_node_get_name (variable_node),
-							   arv_gc_float_get_value (ARV_GC_FLOAT (node)));
+							  value);
+		}
 	}
 
 	if (gc_converter->value != NULL) {
 		node = arv_gc_property_node_get_linked_node (gc_converter->value);
 
-		if (arv_gc_feature_node_get_value_type (ARV_GC_FEATURE_NODE (node)) == G_TYPE_INT64)
+		if (arv_gc_feature_node_get_value_type (ARV_GC_FEATURE_NODE (node)) == G_TYPE_INT64) {
 			arv_gc_integer_set_value (ARV_GC_INTEGER (node),
-						  arv_evaluator_evaluate_as_int64 (gc_converter->formula_to, NULL));
-		else if (arv_gc_feature_node_get_value_type (ARV_GC_FEATURE_NODE (node)) == G_TYPE_DOUBLE)
+						  arv_evaluator_evaluate_as_int64 (gc_converter->formula_to, NULL),
+						  &local_error);
+
+			if (local_error != NULL) {
+				g_propagate_error (error, local_error);
+				return;
+			}
+		} else if (arv_gc_feature_node_get_value_type (ARV_GC_FEATURE_NODE (node)) == G_TYPE_DOUBLE) {
 			arv_gc_float_set_value (ARV_GC_FLOAT (node),
-						arv_evaluator_evaluate_as_double (gc_converter->formula_to, NULL));
-		else
+						arv_evaluator_evaluate_as_double (gc_converter->formula_to, NULL),
+						&local_error);
+
+			if (local_error != NULL) {
+				g_propagate_error (error, local_error);
+				return;
+			}
+		} else
 			arv_warning_genicam ("[GcConverter::set_value] Invalid pValue node '%s'",
 					     gc_converter->value);
 	}
 }
 
 static gint64
-arv_gc_converter_get_integer_value (ArvGcInteger *gc_integer)
+arv_gc_converter_get_integer_value (ArvGcInteger *gc_integer, GError **error)
 {
 	ArvGcConverter *gc_converter = ARV_GC_CONVERTER (gc_integer);
+	GError *local_error = NULL;
 
-	_update_from_variables (gc_converter);
+	_update_from_variables (gc_converter, &local_error);
+
+	if (local_error != NULL) {
+		g_propagate_error (error, local_error);
+		return 0;
+	}
 
 	return arv_evaluator_evaluate_as_int64 (gc_converter->formula_from, NULL);
 }
 
 static void
-arv_gc_converter_set_integer_value (ArvGcInteger *gc_integer, gint64 value)
+arv_gc_converter_set_integer_value (ArvGcInteger *gc_integer, gint64 value, GError **error)
 {
 	ArvGcConverter *gc_converter = ARV_GC_CONVERTER (gc_integer);
 
 	arv_evaluator_set_int64_variable (gc_converter->formula_to,
 					  "FROM", value);
 
-	_update_to_variables (gc_converter);
+	_update_to_variables (gc_converter, error);
 }
 
 static void
@@ -276,24 +360,30 @@ arv_gc_converter_integer_interface_init (ArvGcIntegerInterface *interface)
 }
 
 static double
-arv_gc_converter_get_float_value (ArvGcFloat *gc_float)
+arv_gc_converter_get_float_value (ArvGcFloat *gc_float, GError **error)
 {
 	ArvGcConverter *gc_converter = ARV_GC_CONVERTER (gc_float);
+	GError *local_error = NULL;
 
-	_update_from_variables (gc_converter);
+	_update_from_variables (gc_converter, &local_error);
+
+	if (local_error != NULL) {
+		g_propagate_error (error, local_error);
+		return 0.0;
+	}
 
 	return arv_evaluator_evaluate_as_double (gc_converter->formula_from, NULL);
 }
 
 static void
-arv_gc_converter_set_float_value (ArvGcFloat *gc_float, double value)
+arv_gc_converter_set_float_value (ArvGcFloat *gc_float, double value, GError **error)
 {
 	ArvGcConverter *gc_converter = ARV_GC_CONVERTER (gc_float);
 
 	arv_evaluator_set_double_variable (gc_converter->formula_to,
 					  "FROM", value);
 
-	_update_to_variables (gc_converter);
+	_update_to_variables (gc_converter, error);
 }
 
 static void
diff --git a/src/arvgcfloat.c b/src/arvgcfloat.c
index d98cfb8..777628e 100644
--- a/src/arvgcfloat.c
+++ b/src/arvgcfloat.c
@@ -36,101 +36,109 @@ arv_gc_float_default_init (ArvGcFloatInterface *gc_float_iface)
 G_DEFINE_INTERFACE (ArvGcFloat, arv_gc_float, G_TYPE_OBJECT)
 
 double
-arv_gc_float_get_value (ArvGcFloat *gc_float)
+arv_gc_float_get_value (ArvGcFloat *gc_float, GError **error)
 {
 	g_return_val_if_fail (ARV_IS_GC_FLOAT (gc_float), 0.0);
+	g_return_val_if_fail (error == NULL || *error == NULL, 0.0);
 
-	return ARV_GC_FLOAT_GET_INTERFACE (gc_float)->get_value (gc_float);
+	return ARV_GC_FLOAT_GET_INTERFACE (gc_float)->get_value (gc_float, error);
 }
 
 void
-arv_gc_float_set_value (ArvGcFloat *gc_float, double value)
+arv_gc_float_set_value (ArvGcFloat *gc_float, double value, GError **error)
 {
 	g_return_if_fail (ARV_IS_GC_FLOAT (gc_float));
+	g_return_if_fail (error == NULL || *error == NULL);
 
-	ARV_GC_FLOAT_GET_INTERFACE (gc_float)->set_value (gc_float, value);
+	ARV_GC_FLOAT_GET_INTERFACE (gc_float)->set_value (gc_float, value, error);
 }
 
 double
-arv_gc_float_get_min (ArvGcFloat *gc_float)
+arv_gc_float_get_min (ArvGcFloat *gc_float, GError **error)
 {
 	ArvGcFloatInterface *float_interface;
 
-	g_return_val_if_fail (ARV_IS_GC_FLOAT (gc_float), 0);
+	g_return_val_if_fail (ARV_IS_GC_FLOAT (gc_float), 0.0);
+	g_return_val_if_fail (error == NULL || *error == NULL, 0.0);
 
 	float_interface = ARV_GC_FLOAT_GET_INTERFACE (gc_float);
 
 	if (float_interface->get_min != NULL)
-		return float_interface->get_min (gc_float);
+		return float_interface->get_min (gc_float, error);
 	else
 		return -G_MAXDOUBLE;
 }
 
 double
-arv_gc_float_get_max (ArvGcFloat *gc_float)
+arv_gc_float_get_max (ArvGcFloat *gc_float, GError **error)
 {
 	ArvGcFloatInterface *float_interface;
 
-	g_return_val_if_fail (ARV_IS_GC_FLOAT (gc_float), 0);
+	g_return_val_if_fail (ARV_IS_GC_FLOAT (gc_float), 0.0);
+	g_return_val_if_fail (error == NULL || *error == NULL, 0.0);
 
 	float_interface = ARV_GC_FLOAT_GET_INTERFACE (gc_float);
 
 	if (float_interface->get_max != NULL)
-		return float_interface->get_max (gc_float);
+		return float_interface->get_max (gc_float, error);
 	else
 		return G_MAXDOUBLE;
 }
 
 double
-arv_gc_float_get_inc (ArvGcFloat *gc_float)
+arv_gc_float_get_inc (ArvGcFloat *gc_float, GError **error)
 {
 	ArvGcFloatInterface *float_interface;
 
-	g_return_val_if_fail (ARV_IS_GC_FLOAT (gc_float), 0);
+	g_return_val_if_fail (ARV_IS_GC_FLOAT (gc_float), 0.0);
+	g_return_val_if_fail (error == NULL || *error == NULL, 0.0);
 
 	float_interface = ARV_GC_FLOAT_GET_INTERFACE (gc_float);
 
 	if (float_interface->get_inc != NULL)
-		return float_interface->get_inc (gc_float);
+		return float_interface->get_inc (gc_float, error);
 	else
 		return 1;
 }
 
 const char *
-arv_gc_float_get_unit	(ArvGcFloat *gc_float)
+arv_gc_float_get_unit	(ArvGcFloat *gc_float, GError **error)
 {
 	ArvGcFloatInterface *float_interface;
 
-	g_return_val_if_fail (ARV_IS_GC_FLOAT (gc_float), 0);
+	g_return_val_if_fail (ARV_IS_GC_FLOAT (gc_float), NULL);
+	g_return_val_if_fail (error == NULL || *error == NULL, NULL);
 
 	float_interface = ARV_GC_FLOAT_GET_INTERFACE (gc_float);
 
 	if (float_interface->get_unit != NULL)
-		return float_interface->get_unit (gc_float);
+		return float_interface->get_unit (gc_float, error);
 	else
 		return NULL;
 }
 
-void arv_gc_float_impose_min (ArvGcFloat *gc_float, double minimum)
+void arv_gc_float_impose_min (ArvGcFloat *gc_float, double minimum, GError **error)
 {
 	ArvGcFloatInterface *float_interface;
 
 	g_return_if_fail (ARV_IS_GC_FLOAT (gc_float));
+	g_return_if_fail (error == NULL || *error == NULL);
 
 	float_interface = ARV_GC_FLOAT_GET_INTERFACE (gc_float);
 
 	if (float_interface->impose_min != NULL)
-		float_interface->impose_min (gc_float, minimum);
+		float_interface->impose_min (gc_float, minimum, error);
 }
 
-void arv_gc_float_impose_max (ArvGcFloat *gc_float, double maximum)
+void arv_gc_float_impose_max (ArvGcFloat *gc_float, double maximum, GError **error)
 {
 	ArvGcFloatInterface *float_interface;
 
 	g_return_if_fail (ARV_IS_GC_FLOAT (gc_float));
+	g_return_if_fail (error == NULL || *error == NULL);
 
 	float_interface = ARV_GC_FLOAT_GET_INTERFACE (gc_float);
 
 	if (float_interface->impose_max != NULL)
-		float_interface->impose_max (gc_float, maximum);
+		float_interface->impose_max (gc_float, maximum, error);
 }
diff --git a/src/arvgcfloat.h b/src/arvgcfloat.h
index 4e40e8e..2a6c671 100644
--- a/src/arvgcfloat.h
+++ b/src/arvgcfloat.h
@@ -51,10 +51,10 @@ GType arv_gc_float_get_type (void);
 
 double		arv_gc_float_get_value		(ArvGcFloat *gc_float, GError **error);
 void		arv_gc_float_set_value		(ArvGcFloat *gc_float, double value, GError **error);
-double		arv_gc_float_get_min		(ArvGcFloat *gc_float, GError *error);
-double		arv_gc_float_get_max		(ArvGcFloat *gc_float, GError *error);
-double		arv_gc_float_get_inc		(ArvGcFloat *gc_float, GError *error);
-const char *	arv_gc_float_get_unit		(ArvGcFloat *gc_float, GError *error);
+double		arv_gc_float_get_min		(ArvGcFloat *gc_float, GError **error);
+double		arv_gc_float_get_max		(ArvGcFloat *gc_float, GError **error);
+double		arv_gc_float_get_inc		(ArvGcFloat *gc_float, GError **error);
+const char *	arv_gc_float_get_unit		(ArvGcFloat *gc_float, GError **error);
 void		arv_gc_float_impose_min		(ArvGcFloat *gc_float, double minimum, GError **error);
 void		arv_gc_float_impose_max		(ArvGcFloat *gc_float, double maximum, GError **error);
 
diff --git a/src/arvgcinteger.c b/src/arvgcinteger.c
index 964fe0e..7c56960 100644
--- a/src/arvgcinteger.c
+++ b/src/arvgcinteger.c
@@ -36,101 +36,109 @@ arv_gc_integer_default_init (ArvGcIntegerInterface *gc_integer_iface)
 G_DEFINE_INTERFACE (ArvGcInteger, arv_gc_integer, G_TYPE_OBJECT)
 
 gint64
-arv_gc_integer_get_value (ArvGcInteger *gc_integer)
+arv_gc_integer_get_value (ArvGcInteger *gc_integer, GError **error)
 {
 	g_return_val_if_fail (ARV_IS_GC_INTEGER (gc_integer), 0);
+	g_return_val_if_fail (error == NULL || *error == NULL, 0);
 
-	return ARV_GC_INTEGER_GET_INTERFACE (gc_integer)->get_value (gc_integer);
+	return ARV_GC_INTEGER_GET_INTERFACE (gc_integer)->get_value (gc_integer, error);
 }
 
 void
-arv_gc_integer_set_value (ArvGcInteger *gc_integer, gint64 value)
+arv_gc_integer_set_value (ArvGcInteger *gc_integer, gint64 value, GError **error)
 {
 	g_return_if_fail (ARV_IS_GC_INTEGER (gc_integer));
+	g_return_if_fail (error == NULL || *error == NULL);
 
-	ARV_GC_INTEGER_GET_INTERFACE (gc_integer)->set_value (gc_integer, value);
+	ARV_GC_INTEGER_GET_INTERFACE (gc_integer)->set_value (gc_integer, value, error);
 }
 
 gint64
-arv_gc_integer_get_min (ArvGcInteger *gc_integer)
+arv_gc_integer_get_min (ArvGcInteger *gc_integer, GError **error)
 {
 	ArvGcIntegerInterface *integer_interface;
 
 	g_return_val_if_fail (ARV_IS_GC_INTEGER (gc_integer), 0);
+	g_return_val_if_fail (error == NULL || *error == NULL, 0);
 
 	integer_interface = ARV_GC_INTEGER_GET_INTERFACE (gc_integer);
 
 	if (integer_interface->get_min != NULL)
-		return integer_interface->get_min (gc_integer);
+		return integer_interface->get_min (gc_integer, error);
 	else
 		return G_MININT64;
 }
 
 gint64
-arv_gc_integer_get_max (ArvGcInteger *gc_integer)
+arv_gc_integer_get_max (ArvGcInteger *gc_integer, GError **error)
 {
 	ArvGcIntegerInterface *integer_interface;
 
 	g_return_val_if_fail (ARV_IS_GC_INTEGER (gc_integer), 0);
+	g_return_val_if_fail (error == NULL || *error == NULL, 0);
 
 	integer_interface = ARV_GC_INTEGER_GET_INTERFACE (gc_integer);
 
 	if (integer_interface->get_max != NULL)
-		return integer_interface->get_max (gc_integer);
+		return integer_interface->get_max (gc_integer, error);
 	else
 		return G_MAXINT64;
 }
 
 gint64
-arv_gc_integer_get_inc (ArvGcInteger *gc_integer)
+arv_gc_integer_get_inc (ArvGcInteger *gc_integer, GError **error)
 {
 	ArvGcIntegerInterface *integer_interface;
 
 	g_return_val_if_fail (ARV_IS_GC_INTEGER (gc_integer), 0);
+	g_return_val_if_fail (error == NULL || *error == NULL, 0);
 
 	integer_interface = ARV_GC_INTEGER_GET_INTERFACE (gc_integer);
 
 	if (integer_interface->get_inc != NULL)
-		return integer_interface->get_inc (gc_integer);
+		return integer_interface->get_inc (gc_integer, error);
 	else
 		return 1;
 }
 
 const char *
-arv_gc_integer_get_unit	(ArvGcInteger *gc_integer)
+arv_gc_integer_get_unit	(ArvGcInteger *gc_integer, GError **error)
 {
 	ArvGcIntegerInterface *integer_interface;
 
-	g_return_val_if_fail (ARV_IS_GC_INTEGER (gc_integer), 0);
+	g_return_val_if_fail (ARV_IS_GC_INTEGER (gc_integer), NULL);
+	g_return_val_if_fail (error == NULL || *error == NULL, NULL);
 
 	integer_interface = ARV_GC_INTEGER_GET_INTERFACE (gc_integer);
 
 	if (integer_interface->get_unit != NULL)
-		return integer_interface->get_unit (gc_integer);
+		return integer_interface->get_unit (gc_integer, error);
 	else
 		return NULL;
 }
 
-void arv_gc_integer_impose_min (ArvGcInteger *gc_integer, gint64 minimum)
+void arv_gc_integer_impose_min (ArvGcInteger *gc_integer, gint64 minimum, GError **error)
 {
 	ArvGcIntegerInterface *integer_interface;
 
 	g_return_if_fail (ARV_IS_GC_INTEGER (gc_integer));
+	g_return_if_fail (error == NULL || *error == NULL);
 
 	integer_interface = ARV_GC_INTEGER_GET_INTERFACE (gc_integer);
 
 	if (integer_interface->impose_min != NULL)
-		integer_interface->impose_min (gc_integer, minimum);
+		integer_interface->impose_min (gc_integer, minimum, error);
 }
 
-void arv_gc_integer_impose_max (ArvGcInteger *gc_integer, gint64 maximum)
+void arv_gc_integer_impose_max (ArvGcInteger *gc_integer, gint64 maximum, GError **error)
 {
 	ArvGcIntegerInterface *integer_interface;
 
 	g_return_if_fail (ARV_IS_GC_INTEGER (gc_integer));
+	g_return_if_fail (error == NULL || *error == NULL);
 
 	integer_interface = ARV_GC_INTEGER_GET_INTERFACE (gc_integer);
 
 	if (integer_interface->impose_max != NULL)
-		integer_interface->impose_max (gc_integer, maximum);
+		integer_interface->impose_max (gc_integer, maximum, error);
 }
diff --git a/src/arvgcinteger.h b/src/arvgcinteger.h
index eb7123d..0837b4a 100644
--- a/src/arvgcinteger.h
+++ b/src/arvgcinteger.h
@@ -55,8 +55,8 @@ gint64		arv_gc_integer_get_min		(ArvGcInteger *gc_integer, GError **error);
 gint64		arv_gc_integer_get_max		(ArvGcInteger *gc_integer, GError **error);
 gint64		arv_gc_integer_get_inc		(ArvGcInteger *gc_integer, GError **error);
 const char *	arv_gc_integer_get_unit		(ArvGcInteger *gc_integer, GError **error);
-void		arv_gc_integer_impose_min	(ArvGcInteger *gc_integer, gint64 minimum, GError *error);
-void		arv_gc_integer_impose_max	(ArvGcInteger *gc_integer, gint64 maximum, GError *error);
+void		arv_gc_integer_impose_min	(ArvGcInteger *gc_integer, gint64 minimum, GError **error);
+void		arv_gc_integer_impose_max	(ArvGcInteger *gc_integer, gint64 maximum, GError **error);
 
 /* FIXME get_representation is missing */
 
diff --git a/src/arvgcport.c b/src/arvgcport.c
index cbddaf0..8cf2a89 100644
--- a/src/arvgcport.c
+++ b/src/arvgcport.c
@@ -42,12 +42,13 @@ arv_gc_port_get_node_name (ArvDomNode *node)
 /* ArvGcPort implementation */
 
 void
-arv_gc_port_read (ArvGcPort *port, void *buffer, guint64 address, guint64 length)
+arv_gc_port_read (ArvGcPort *port, void *buffer, guint64 address, guint64 length, GError **error)
 {
 	ArvGc *genicam;
 	ArvDevice *device;
 
 	g_return_if_fail (ARV_IS_GC_PORT (port));
+	g_return_if_fail (error == NULL || *error == NULL);
 
 	genicam = arv_gc_node_get_genicam (ARV_GC_NODE (port));
 	device = arv_gc_get_device (genicam);
@@ -56,12 +57,13 @@ arv_gc_port_read (ArvGcPort *port, void *buffer, guint64 address, guint64 length
 }
 
 void
-arv_gc_port_write (ArvGcPort *port, void *buffer, guint64 address, guint64 length)
+arv_gc_port_write (ArvGcPort *port, void *buffer, guint64 address, guint64 length, GError **error)
 {
 	ArvGc *genicam;
 	ArvDevice *device;
 
 	g_return_if_fail (ARV_IS_GC_PORT (port));
+	g_return_if_fail (error == NULL || *error == NULL);
 
 	genicam = arv_gc_node_get_genicam (ARV_GC_NODE (port));
 	device = arv_gc_get_device (genicam);
diff --git a/src/arvgcregister.c b/src/arvgcregister.c
index d4e6d80..ff70c16 100644
--- a/src/arvgcregister.c
+++ b/src/arvgcregister.c
@@ -36,37 +36,41 @@ arv_gc_register_default_init (ArvGcRegisterInterface *gc_register_iface)
 G_DEFINE_INTERFACE (ArvGcRegister, arv_gc_register, G_TYPE_OBJECT)
 
 void
-arv_gc_register_get (ArvGcRegister *gc_register, void *buffer, guint64 length)
+arv_gc_register_get (ArvGcRegister *gc_register, void *buffer, guint64 length, GError **error)
 {
 	g_return_if_fail (ARV_IS_GC_REGISTER (gc_register));
 	g_return_if_fail (buffer != NULL);
 	g_return_if_fail (length > 0);
+	g_return_if_fail (error == NULL || *error == NULL);
 
-	ARV_GC_REGISTER_GET_INTERFACE (gc_register)->get (gc_register, buffer, length);
+	ARV_GC_REGISTER_GET_INTERFACE (gc_register)->get (gc_register, buffer, length, error);
 }
 
 void
-arv_gc_register_set (ArvGcRegister *gc_register, void *buffer, guint64 length)
+arv_gc_register_set (ArvGcRegister *gc_register, void *buffer, guint64 length, GError **error)
 {
 	g_return_if_fail (ARV_IS_GC_REGISTER (gc_register));
 	g_return_if_fail (buffer != NULL);
 	g_return_if_fail (length > 0);
+	g_return_if_fail (error == NULL || *error == NULL);
 
-	ARV_GC_REGISTER_GET_INTERFACE (gc_register)->set (gc_register, buffer, length);
+	ARV_GC_REGISTER_GET_INTERFACE (gc_register)->set (gc_register, buffer, length, error);
 }
 
 guint64
-arv_gc_register_get_address (ArvGcRegister *gc_register)
+arv_gc_register_get_address (ArvGcRegister *gc_register, GError **error)
 {
 	g_return_val_if_fail (ARV_IS_GC_REGISTER (gc_register), 0);
+	g_return_val_if_fail (error == NULL || *error == NULL, 0);
 
-	return ARV_GC_REGISTER_GET_INTERFACE (gc_register)->get_address (gc_register);
+	return ARV_GC_REGISTER_GET_INTERFACE (gc_register)->get_address (gc_register, error);
 }
 
 guint64
-arv_gc_register_get_length (ArvGcRegister *gc_register)
+arv_gc_register_get_length (ArvGcRegister *gc_register, GError **error)
 {
 	g_return_val_if_fail (ARV_IS_GC_REGISTER (gc_register), 0);
+	g_return_val_if_fail (error == NULL || *error == NULL, 0);
 
-	return ARV_GC_REGISTER_GET_INTERFACE (gc_register)->get_length (gc_register);
+	return ARV_GC_REGISTER_GET_INTERFACE (gc_register)->get_length (gc_register, error);
 }
diff --git a/src/arvgcstring.c b/src/arvgcstring.c
index effdb32..aa7e1ff 100644
--- a/src/arvgcstring.c
+++ b/src/arvgcstring.c
@@ -36,32 +36,35 @@ arv_gc_string_default_init (ArvGcStringInterface *gc_string_iface)
 G_DEFINE_INTERFACE (ArvGcString, arv_gc_string, G_TYPE_OBJECT)
 
 const char *
-arv_gc_string_get_value (ArvGcString *gc_string)
+arv_gc_string_get_value (ArvGcString *gc_string, GError **error)
 {
 	g_return_val_if_fail (ARV_IS_GC_STRING (gc_string), NULL);
+	g_return_val_if_fail (error == NULL || *error == NULL, NULL);
 
-	return ARV_GC_STRING_GET_INTERFACE (gc_string)->get_value (gc_string);
+	return ARV_GC_STRING_GET_INTERFACE (gc_string)->get_value (gc_string, error);
 }
 
 void
-arv_gc_string_set_value (ArvGcString *gc_string, const char *value)
+arv_gc_string_set_value (ArvGcString *gc_string, const char *value, GError **error)
 {
 	g_return_if_fail (ARV_IS_GC_STRING (gc_string));
+	g_return_if_fail (error == NULL || *error == NULL);
 
-	ARV_GC_STRING_GET_INTERFACE (gc_string)->set_value (gc_string, value);
+	ARV_GC_STRING_GET_INTERFACE (gc_string)->set_value (gc_string, value, error);
 }
 
 gint64
-arv_gc_string_get_max_length (ArvGcString *gc_string)
+arv_gc_string_get_max_length (ArvGcString *gc_string, GError **error)
 {
 	ArvGcStringInterface *string_interface;
 
 	g_return_val_if_fail (ARV_IS_GC_STRING (gc_string), 0);
+	g_return_val_if_fail (error == NULL || *error == NULL, 0);
 
 	string_interface = ARV_GC_STRING_GET_INTERFACE (gc_string);
 
 	if (string_interface->get_max_length != NULL)
-		return string_interface->get_max_length (gc_string);
+		return string_interface->get_max_length (gc_string, error);
 	else
 		return 0;
 }
[Date Prev][Date Next]   [Thread Prev][Thread Next]   [Thread Index] [Date Index] [Author Index]