performing initialization of signature iterators outside EncodeObject, to simplify recursion a bit

mokus0 · mokus0 · commit c607e48c4c28 · 2017-08-31T13:26:07.000-07:00
diff --git a/src/dbus.cc b/src/dbus.cc
@@ -214,9 +214,11 @@ namespace NodeDBus {
 				dbus_signature_iter_init(&siter, sig);
 				for (unsigned int i = 0; i < argument_arr->Length(); ++i) {
 					char *arg_sig = dbus_signature_iter_get_signature(&siter);
+					DBusSignatureIter subSiter;
 					Local<Value> arg = argument_arr->Get(i);
 
-					if (!Encoder::EncodeObject(arg, &iter, arg_sig)) {
+					dbus_signature_iter_init(&subSiter, arg_sig);
+					if (!Encoder::EncodeObject(arg, &iter, &subSiter)) {
 						dbus_free(arg_sig);
 						break;
 					}
diff --git a/src/encoder.cc b/src/encoder.cc
@@ -151,17 +151,15 @@ typedef bool (*CheckTypeCallback) (Local<Value>& value, const char* sig);
 		return "";
 	}
 
-	bool EncodeObject(Local<Value> value, DBusMessageIter *iter, const char *signature)
+	bool EncodeObject(Local<Value> value, DBusMessageIter *iter, DBusSignatureIter *siter)
 	{
 		// printf("EncodeObject %s\n",signature);
 		// printf("%p", value);
 		Nan::HandleScope scope;
-		DBusSignatureIter siter;
 		int type;
 
 		// Get type of current value
-		dbus_signature_iter_init(&siter, signature);
-		type = dbus_signature_iter_get_current_type(&siter);
+		type = dbus_signature_iter_get_current_type(siter);
 
 		switch(type) {
 		case DBUS_TYPE_INVALID:
@@ -319,7 +317,7 @@ typedef bool (*CheckTypeCallback) (Local<Value>& value, const char* sig);
 			char *array_sig = NULL;
 
 			// Getting signature of array object
-			dbus_signature_iter_recurse(&siter, &arraySiter);
+			dbus_signature_iter_recurse(siter, &arraySiter);
 			array_sig = dbus_signature_iter_get_signature(&arraySiter);
 
 			// Open array container to process elements in there
@@ -328,28 +326,23 @@ typedef bool (*CheckTypeCallback) (Local<Value>& value, const char* sig);
 				printf("Can't open container for Array type\n");
 				return false; 
 			}
+			dbus_free(array_sig);
 
 			// It's a dictionary
-			if (dbus_signature_iter_get_element_type(&siter) == DBUS_TYPE_DICT_ENTRY) {
-
-				dbus_free(array_sig);
-
+			if (dbus_signature_iter_get_element_type(siter) == DBUS_TYPE_DICT_ENTRY) {
 				Local<Object> value_object = value->ToObject();
-				DBusSignatureIter dictSubSiter;
-
-				// Getting sub-signature object
-				dbus_signature_iter_recurse(&arraySiter, &dictSubSiter);
-				char *keySig = dbus_signature_iter_get_signature(&dictSubSiter);
-				dbus_signature_iter_next(&dictSubSiter);
-				char *valSig = dbus_signature_iter_get_signature(&dictSubSiter);
 
 				// process each elements
 				Local<Array> prop_names = value_object->GetPropertyNames();
 				unsigned int len = prop_names->Length();
 
 				bool failed = false;
 				for (unsigned int i = 0; i < len; ++i) {
+					DBusSignatureIter dictSubSiter;
 					DBusMessageIter dict_iter;
+					
+					// Getting sub-signature object
+					dbus_signature_iter_recurse(&arraySiter, &dictSubSiter);
 
 					// Open dict entry container
 					if (!dbus_message_iter_open_container(&subIter, DBUS_TYPE_DICT_ENTRY, NULL, &dict_iter)) {
@@ -363,15 +356,16 @@ typedef bool (*CheckTypeCallback) (Local<Value>& value, const char* sig);
 					Local<Value> prop_value = value_object->Get(prop_key);
 
 					// Append the key
-					if (!EncodeObject(prop_key, &dict_iter, keySig)) {
+					if (!EncodeObject(prop_key, &dict_iter, &dictSubSiter)) {
 						dbus_message_iter_close_container(&subIter, &dict_iter); 
 						printf("Failed to encode element of dictionary\n");
 						failed = true;
 						break;
 					}
 
 					// Append the value
-					if (!EncodeObject(prop_value, &dict_iter, valSig)) {
+					dbus_signature_iter_next(&dictSubSiter);
+					if (!EncodeObject(prop_value, &dict_iter, &dictSubSiter)) {
 						dbus_message_iter_close_container(&subIter, &dict_iter); 
 						printf("Failed to encode element of dictionary\n");
 						failed = true;
@@ -381,8 +375,6 @@ typedef bool (*CheckTypeCallback) (Local<Value>& value, const char* sig);
 					dbus_message_iter_close_container(&subIter, &dict_iter); 
 				}
 
-				dbus_free(keySig);
-				dbus_free(valSig);
 				dbus_message_iter_close_container(iter, &subIter);
 
 				if (failed) 
@@ -400,19 +392,19 @@ typedef bool (*CheckTypeCallback) (Local<Value>& value, const char* sig);
 			Local<Array> arrayData = Local<Array>::Cast(value);
 			for (unsigned int i = 0; i < arrayData->Length(); ++i) {
 				Local<Value> arrayItem = arrayData->Get(i);
-				if (!EncodeObject(arrayItem, &subIter, array_sig))
+				if (!EncodeObject(arrayItem, &subIter, &arraySiter))
 					break;
 			}
 
 			dbus_message_iter_close_container(iter, &subIter);
-			dbus_free(array_sig);
 
 			break;
 		}
 
 		case DBUS_TYPE_VARIANT:
 		{
 			DBusMessageIter subIter;
+			DBusSignatureIter subSiter;
 
 			string str_sig = GetSignatureFromV8Type(value);
 			const char *var_sig = str_sig.c_str();
@@ -422,7 +414,8 @@ typedef bool (*CheckTypeCallback) (Local<Value>& value, const char* sig);
 				return false;
 			}
 
-			if (!EncodeObject(value, &subIter, var_sig)) { 
+			dbus_signature_iter_init(&subSiter, var_sig);
+			if (!EncodeObject(value, &subIter, &subSiter)) { 
 				dbus_message_iter_close_container(iter, &subIter);
 				return false;
 			}
@@ -446,26 +439,21 @@ typedef bool (*CheckTypeCallback) (Local<Value>& value, const char* sig);
 			Local<Object> value_object = value->ToObject();
 
 			// Getting sub-signature object
-			dbus_signature_iter_recurse(&siter, &structSiter);
+			dbus_signature_iter_recurse(siter, &structSiter);
 
 			// process each elements
 			Local<Array> prop_names = value_object->GetPropertyNames();
 			unsigned int len = prop_names->Length();
 
 			for (unsigned int i = 0; i < len; ++i) {
 
-				char *sig = dbus_signature_iter_get_signature(&structSiter);
-
 				Local<Value> prop_key = prop_names->Get(i);
 
-				if (!EncodeObject(value_object->Get(prop_key), &subIter, sig)) {
-					dbus_free(sig);
+				if (!EncodeObject(value_object->Get(prop_key), &subIter, &structSiter)) {
 					printf("Failed to encode element of dictionary\n");
 					return false;
 				}
 
-				dbus_free(sig);
-
 				if (!dbus_signature_iter_next(&structSiter))
 					break;
 			}
diff --git a/src/encoder.h b/src/encoder.h
@@ -8,7 +8,7 @@ namespace Encoder {
 	using namespace std;
 
 	string GetSignatureFromV8Type(Local<Value>& value);
-	bool EncodeObject(Local<Value> value, DBusMessageIter *iter, const char *signature);
+	bool EncodeObject(Local<Value> value, DBusMessageIter *iter, DBusSignatureIter *siter);
 }
 
 #endif
diff --git a/src/object_handler.cc b/src/object_handler.cc
@@ -77,13 +77,15 @@ namespace ObjectHandler {
 	{
 		Nan::HandleScope scope;
 		DBusMessageIter iter;
+		DBusSignatureIter siter;
 		DBusMessage *reply;
 		dbus_uint32_t serial = 0;
 
 		reply = dbus_message_new_method_return(message);
 
 		dbus_message_iter_init_append(reply, &iter);
-		if (!Encoder::EncodeObject(reply_value, &iter, signature)) {
+		dbus_signature_iter_init(&siter, signature);
+		if (!Encoder::EncodeObject(reply_value, &iter, &siter)) {
 			printf("Failed to encode reply value\n");
 		}
 
diff --git a/src/signal.cc b/src/signal.cc
@@ -41,6 +41,8 @@ namespace Signal {
 	}
 
 	NAN_METHOD(EmitSignal) {
+		DBusError error;
+
 		if (!info[0]->IsObject()) {
 			return Nan::ThrowTypeError("First parameter must be an object");
 		}
@@ -80,6 +82,9 @@ namespace Signal {
 		char *signal = strdup(*String::Utf8Value(info[3]->ToString()));
 		message = dbus_message_new_signal(path, interface, signal);
 
+		// Initializing error handler
+		dbus_error_init(&error);
+
 		// Preparing message
 		dbus_message_iter_init_append(message, &iter);
 
@@ -88,10 +93,15 @@ namespace Signal {
 		Local<Array> signatures = Local<Array>::Cast(info[5]);
 		for (unsigned int i = 0; i < arguments->Length(); ++i) {
 			Local<Value> arg = arguments->Get(i);
-
+			DBusSignatureIter siter;
+			
 			char *sig = strdup(*String::Utf8Value(signatures->Get(i)->ToString()));
-
-			if (!Encoder::EncodeObject(arg, &iter, sig)) {
+			if (!dbus_signature_validate(sig, &error)) {
+				return Nan::ThrowError(error.message);
+			}
+			
+			dbus_signature_iter_init(&siter, sig);
+			if (!Encoder::EncodeObject(arg, &iter, &siter)) {
 				dbus_free(sig);
 				printf("Failed to encode arguments of signal\n");
 				break;

Original file line number	Diff line number	Diff line change
`@@ -8,7 +8,7 @@ namespace Encoder {`
`8`	`8`	`using namespace std;`
`9`	`9`
`10`	`10`	`string GetSignatureFromV8Type(Local<Value>& value);`
`11`		`- bool EncodeObject(Local<Value> value, DBusMessageIter iter, const char signature);`
	`11`	`+ bool EncodeObject(Local<Value> value, DBusMessageIter iter, DBusSignatureIter siter);`
`12`	`12`	`}`
`13`	`13`
`14`	`14`	`#endif`
Original file line number	Diff line number	Diff line change
`@@ -77,13 +77,15 @@ namespace ObjectHandler {`
`77`	`77`	`{`
`78`	`78`	`Nan::HandleScope scope;`
`79`	`79`	`DBusMessageIter iter;`
	`80`	`+ DBusSignatureIter siter;`
`80`	`81`	`DBusMessage *reply;`
`81`	`82`	`dbus_uint32_t serial = 0;`
`82`	`83`
`83`	`84`	`reply = dbus_message_new_method_return(message);`
`84`	`85`
`85`	`86`	`dbus_message_iter_init_append(reply, &iter);`
`86`		`- if (!Encoder::EncodeObject(reply_value, &iter, signature)) {`
	`87`	`+ dbus_signature_iter_init(&siter, signature);`
	`88`	`+ if (!Encoder::EncodeObject(reply_value, &iter, &siter)) {`
`87`	`89`	`printf("Failed to encode reply value\n");`
`88`	`90`	`}`
`89`	`91`