Merged pull request #826

Author: derickr

phongo_compat.h

@@ -136,6 +136,13 @@
 	do {              \
 		(*x) = NULL;  \
 	} while (0)
+#define ZVAL_ARR(z, a)               \
+	do {                             \
+		HashTable* __arr = (a);      \
+		zval*      __z   = (z);      \
+		Z_ARRVAL_P(__z)  = __arr;    \
+		Z_TYPE_P(__z)    = IS_ARRAY; \
+	} while (0);
 #define phongo_free_object_arg void
 #define phongo_zpp_char_len int
 #define ZEND_HASH_APPLY_PROTECTION(ht) 1

phongo_version.h

@@ -17,8 +17,10 @@
 #ifndef PHONGO_VERSION_H
 #define PHONGO_VERSION_H
 
+/* clang-format off */
 #define PHP_MONGODB_VERSION "1.5.0-dev"
 #define PHP_MONGODB_STABILITY "devel"
 #define PHP_MONGODB_VERSION_DESC 1,5,0,0
+/* clang-format on */
 
-#endif  /* PHONGO_VERSION_H */
+#endif /* PHONGO_VERSION_H */

php_phongo.c

@@ -1266,52 +1266,6 @@ bool php_phongo_read_preference_tags_are_valid(const bson_t* tags) /* {{{ */
 	return true;
 } /* }}} */
 
-void php_phongo_read_preference_to_zval(zval* retval, const mongoc_read_prefs_t* read_prefs) /* {{{ */
-{
-	const bson_t*      tags = mongoc_read_prefs_get_tags(read_prefs);
-	mongoc_read_mode_t mode = mongoc_read_prefs_get_mode(read_prefs);
-
-	array_init_size(retval, 3);
-
-	switch (mode) {
-		case MONGOC_READ_PRIMARY:
-			ADD_ASSOC_STRING(retval, "mode", "primary");
-			break;
-		case MONGOC_READ_PRIMARY_PREFERRED:
-			ADD_ASSOC_STRING(retval, "mode", "primaryPreferred");
-			break;
-		case MONGOC_READ_SECONDARY:
-			ADD_ASSOC_STRING(retval, "mode", "secondary");
-			break;
-		case MONGOC_READ_SECONDARY_PREFERRED:
-			ADD_ASSOC_STRING(retval, "mode", "secondaryPreferred");
-			break;
-		case MONGOC_READ_NEAREST:
-			ADD_ASSOC_STRING(retval, "mode", "nearest");
-			break;
-		default: /* Do nothing */
-			break;
-	}
-
-	if (!bson_empty0(tags)) {
-		/* Use PHONGO_TYPEMAP_NATIVE_ARRAY for the root type since tags is an
-		 * array; however, inner documents and arrays can use the default. */
-		php_phongo_bson_state state = PHONGO_BSON_STATE_INITIALIZER;
-		state.map.root_type         = PHONGO_TYPEMAP_NATIVE_ARRAY;
-
-		php_phongo_bson_to_zval_ex(bson_get_data(tags), tags->len, &state);
-#if PHP_VERSION_ID >= 70000
-		ADD_ASSOC_ZVAL_EX(retval, "tags", &state.zchild);
-#else
-		ADD_ASSOC_ZVAL_EX(retval, "tags", state.zchild);
-#endif
-	}
-
-	if (mongoc_read_prefs_get_max_staleness_seconds(read_prefs) != MONGOC_NO_MAX_STALENESS) {
-		ADD_ASSOC_LONG_EX(retval, "maxStalenessSeconds", mongoc_read_prefs_get_max_staleness_seconds(read_prefs));
-	}
-} /* }}} */
-
 void php_phongo_write_concern_to_zval(zval* retval, const mongoc_write_concern_t* write_concern) /* {{{ */
 {
 	const char*   wtag     = mongoc_write_concern_get_wtag(write_concern);

php_phongo.h

@@ -155,7 +155,6 @@ bool php_phongo_read_preference_tags_are_valid(const bson_t* tags);
 
 void php_phongo_server_to_zval(zval* retval, mongoc_server_description_t* sd);
 void php_phongo_read_concern_to_zval(zval* retval, const mongoc_read_concern_t* read_concern);
-void php_phongo_read_preference_to_zval(zval* retval, const mongoc_read_prefs_t* read_prefs);
 void php_phongo_write_concern_to_zval(zval* retval, const mongoc_write_concern_t* write_concern);
 void php_phongo_cursor_to_zval(zval* retval, const mongoc_cursor_t* cursor);
 

php_phongo_structs.h

@@ -93,12 +93,14 @@ typedef struct {
 typedef struct {
 	PHONGO_ZEND_OBJECT_PRE
 	mongoc_read_concern_t* read_concern;
+	HashTable*             properties;
 	PHONGO_ZEND_OBJECT_POST
 } php_phongo_readconcern_t;
 
 typedef struct {
 	PHONGO_ZEND_OBJECT_PRE
 	mongoc_read_prefs_t* read_preference;
+	HashTable*           properties;
 	PHONGO_ZEND_OBJECT_POST
 } php_phongo_readpreference_t;
 
@@ -117,6 +119,7 @@ typedef struct {
 
 typedef struct {
 	PHONGO_ZEND_OBJECT_PRE
+	HashTable*              properties;
 	mongoc_write_concern_t* write_concern;
 	PHONGO_ZEND_OBJECT_POST
 } php_phongo_writeconcern_t;

src/MongoDB/ReadConcern.c

@@ -97,17 +97,49 @@ static PHP_METHOD(ReadConcern, isDefault)
 	RETURN_BOOL(mongoc_read_concern_is_default(intern->read_concern));
 } /* }}} */
 
+static HashTable* php_phongo_read_concern_get_properties_hash(zval* object, bool is_debug TSRMLS_DC) /* {{{ */
+{
+	php_phongo_readconcern_t* intern;
+	HashTable*                props;
+	const char*               level;
+
+	intern = Z_READCONCERN_OBJ_P(object);
+
+	PHONGO_GET_PROPERTY_HASH_INIT_PROPS(is_debug, intern, props, 1);
+
+	if (!intern->read_concern) {
+		return props;
+	}
+
+	level = mongoc_read_concern_get_level(intern->read_concern);
+
+	if (level) {
+#if PHP_VERSION_ID >= 70000
+		zval z_level;
+
+		ZVAL_STRING(&z_level, level);
+		zend_hash_str_update(props, "level", sizeof("level") - 1, &z_level);
+#else
+		zval* z_level;
+
+		MAKE_STD_ZVAL(z_level);
+		ZVAL_STRING(z_level, level, 1);
+		zend_hash_update(props, "level", sizeof("level"), &z_level, sizeof(z_level), NULL);
+#endif
+	}
+
+	return props;
+} /* }}} */
+
 /* {{{ proto array MongoDB\Driver\ReadConcern::bsonSerialize()
 */
 static PHP_METHOD(ReadConcern, bsonSerialize)
 {
-	const mongoc_read_concern_t* read_concern = phongo_read_concern_from_zval(getThis() TSRMLS_CC);
-
 	if (zend_parse_parameters_none() == FAILURE) {
 		return;
 	}
 
-	php_phongo_read_concern_to_zval(return_value, read_concern);
+	ZVAL_ARR(return_value, php_phongo_read_concern_get_properties_hash(getThis(), true TSRMLS_CC));
 	convert_to_object(return_value);
 } /* }}} */
 
@@ -139,6 +171,11 @@ static void php_phongo_readconcern_free_object(phongo_free_object_arg* object TS
 
 	zend_object_std_dtor(&intern->std TSRMLS_CC);
 
+	if (intern->properties) {
+		zend_hash_destroy(intern->properties);
+		FREE_HASHTABLE(intern->properties);
+	}
+
 	if (intern->read_concern) {
 		mongoc_read_concern_destroy(intern->read_concern);
 	}
@@ -174,15 +211,14 @@ static phongo_create_object_retval php_phongo_readconcern_create_object(zend_cla
 
 static HashTable* php_phongo_readconcern_get_debug_info(zval* object, int* is_temp TSRMLS_DC) /* {{{ */
 {
-	zval                         retval       = ZVAL_STATIC_INIT;
-	const mongoc_read_concern_t* read_concern = phongo_read_concern_from_zval(object TSRMLS_CC);
-
 	*is_temp = 1;
-	php_phongo_read_concern_to_zval(&retval, read_concern);
+	return php_phongo_read_concern_get_properties_hash(object, true TSRMLS_CC);
+} /* }}} */
 
-	return Z_ARRVAL(retval);
+static HashTable* php_phongo_readconcern_get_properties(zval* object TSRMLS_DC) /* {{{ */
+{
+	return php_phongo_read_concern_get_properties_hash(object, false TSRMLS_CC);
 } /* }}} */
-/* }}} */
 
 void php_phongo_readconcern_init_ce(INIT_FUNC_ARGS) /* {{{ */
 {
@@ -198,6 +234,7 @@ void php_phongo_readconcern_init_ce(INIT_FUNC_ARGS) /* {{{ */
 
 	memcpy(&php_phongo_handler_readconcern, phongo_get_std_object_handlers(), sizeof(zend_object_handlers));
 	php_phongo_handler_readconcern.get_debug_info = php_phongo_readconcern_get_debug_info;
+	php_phongo_handler_readconcern.get_properties = php_phongo_readconcern_get_properties;
 #if PHP_VERSION_ID >= 70000
 	php_phongo_handler_readconcern.free_obj = php_phongo_readconcern_free_object;
 	php_phongo_handler_readconcern.offset   = XtOffsetOf(php_phongo_readconcern_t, std);

src/MongoDB/ReadPreference.c

@@ -202,17 +202,105 @@ static PHP_METHOD(ReadPreference, getTagSets)
 	}
 } /* }}} */
 
+static HashTable* php_phongo_readpreference_get_properties_hash(zval* object, bool is_debug TSRMLS_DC) /* {{{ */
+{
+	php_phongo_readpreference_t* intern;
+	HashTable*                   props;
+	const char*                  modeString = NULL;
+	const bson_t*                tags;
+	mongoc_read_mode_t           mode;
+
+	intern = Z_READPREFERENCE_OBJ_P(object);
+
+	PHONGO_GET_PROPERTY_HASH_INIT_PROPS(is_debug, intern, props, 3);
+
+	if (!intern->read_preference) {
+		return props;
+	}
+
+	tags = mongoc_read_prefs_get_tags(intern->read_preference);
+	mode = mongoc_read_prefs_get_mode(intern->read_preference);
+
+	switch (mode) {
+		case MONGOC_READ_PRIMARY:
+			modeString = "primary";
+			break;
+		case MONGOC_READ_PRIMARY_PREFERRED:
+			modeString = "primaryPreferred";
+			break;
+		case MONGOC_READ_SECONDARY:
+			modeString = "secondary";
+			break;
+		case MONGOC_READ_SECONDARY_PREFERRED:
+			modeString = "secondaryPreferred";
+			break;
+		case MONGOC_READ_NEAREST:
+			modeString = "nearest";
+			break;
+		default: /* Do nothing */
+			break;
+	}
+
+	if (modeString) {
+#if PHP_VERSION_ID >= 70000
+		zval z_mode;
+
+		ZVAL_STRING(&z_mode, modeString);
+		zend_hash_str_update(props, "mode", sizeof("mode") - 1, &z_mode);
+#else
+		zval* z_mode;
+
+		MAKE_STD_ZVAL(z_mode);
+		ZVAL_STRING(z_mode, modeString, 1);
+		zend_hash_update(props, "mode", sizeof("mode"), &z_mode, sizeof(z_mode), NULL);
+#endif
+	}
+
+	if (!bson_empty0(tags)) {
+		/* Use PHONGO_TYPEMAP_NATIVE_ARRAY for the root type since tags is an
+		 * array; however, inner documents and arrays can use the default. */
+		php_phongo_bson_state state = PHONGO_BSON_STATE_INITIALIZER;
+		state.map.root_type         = PHONGO_TYPEMAP_NATIVE_ARRAY;
+
+		php_phongo_bson_to_zval_ex(bson_get_data(tags), tags->len, &state);
+#if PHP_VERSION_ID >= 70000
+		Z_ADDREF(state.zchild);
+		zend_hash_str_update(props, "tags", sizeof("tags") - 1, &state.zchild);
+#else
+		Z_ADDREF_P(state.zchild);
+		zend_hash_update(props, "tags", sizeof("tags"), &state.zchild, sizeof(state.zchild), NULL);
+#endif
+		zval_ptr_dtor(&state.zchild);
+	}
+
+	if (mongoc_read_prefs_get_max_staleness_seconds(intern->read_preference) != MONGOC_NO_MAX_STALENESS) {
+		long maxStalenessSeconds = mongoc_read_prefs_get_max_staleness_seconds(intern->read_preference);
+#if PHP_VERSION_ID >= 70000
+		zval z_max_ss;
+
+		ZVAL_LONG(&z_max_ss, maxStalenessSeconds);
+		zend_hash_str_update(props, "maxStalenessSeconds", sizeof("maxStalenessSeconds") - 1, &z_max_ss);
+#else
+		zval* z_max_ss;
+
+		MAKE_STD_ZVAL(z_max_ss);
+		ZVAL_LONG(z_max_ss, maxStalenessSeconds);
+		zend_hash_update(props, "maxStalenessSeconds", sizeof("maxStalenessSeconds"), &z_max_ss, sizeof(z_max_ss), NULL);
+#endif
+	}
+
+	return props;
+} /* }}} */
+
 /* {{{ proto array MongoDB\Driver\ReadPreference::bsonSerialize()
 */
 static PHP_METHOD(ReadPreference, bsonSerialize)
 {
-	const mongoc_read_prefs_t* read_preference = phongo_read_preference_from_zval(getThis() TSRMLS_CC);
-
 	if (zend_parse_parameters_none() == FAILURE) {
 		return;
 	}
 
-	php_phongo_read_preference_to_zval(return_value, read_preference);
+	ZVAL_ARR(return_value, php_phongo_readpreference_get_properties_hash(getThis(), true TSRMLS_CC));
 	convert_to_object(return_value);
 } /* }}} */
 
@@ -247,6 +335,11 @@ static void php_phongo_readpreference_free_object(phongo_free_object_arg* object
 
 	zend_object_std_dtor(&intern->std TSRMLS_CC);
 
+	if (intern->properties) {
+		zend_hash_destroy(intern->properties);
+		FREE_HASHTABLE(intern->properties);
+	}
+
 	if (intern->read_preference) {
 		mongoc_read_prefs_destroy(intern->read_preference);
 	}
@@ -282,14 +375,13 @@ static phongo_create_object_retval php_phongo_readpreference_create_object(zend_
 
 static HashTable* php_phongo_readpreference_get_debug_info(zval* object, int* is_temp TSRMLS_DC) /* {{{ */
 {
-	zval                       retval     = ZVAL_STATIC_INIT;
-	const mongoc_read_prefs_t* read_prefs = phongo_read_preference_from_zval(object TSRMLS_CC);
-
 	*is_temp = 1;
+	return php_phongo_readpreference_get_properties_hash(object, true TSRMLS_CC);
+} /* }}} */
 
-	php_phongo_read_preference_to_zval(&retval, read_prefs);
-
-	return Z_ARRVAL(retval);
+static HashTable* php_phongo_readpreference_get_properties(zval* object TSRMLS_DC) /* {{{ */
+{
+	return php_phongo_readpreference_get_properties_hash(object, false TSRMLS_CC);
 } /* }}} */
 /* }}} */
 
@@ -307,6 +399,7 @@ void php_phongo_readpreference_init_ce(INIT_FUNC_ARGS) /* {{{ */
 
 	memcpy(&php_phongo_handler_readpreference, phongo_get_std_object_handlers(), sizeof(zend_object_handlers));
 	php_phongo_handler_readpreference.get_debug_info = php_phongo_readpreference_get_debug_info;
+	php_phongo_handler_readpreference.get_properties = php_phongo_readpreference_get_properties;
 #if PHP_VERSION_ID >= 70000
 	php_phongo_handler_readpreference.free_obj = php_phongo_readpreference_free_object;
 	php_phongo_handler_readpreference.offset   = XtOffsetOf(php_phongo_readpreference_t, std);