libs/utils/src/properties_encoding.c - celix - Git at Google

 /*
  * Licensed to the Apache Software Foundation (ASF) under one
  * or more contributor license agreements.  See the NOTICE file
  * distributed with this work for additional information
  * regarding copyright ownership.  The ASF licenses this file
  * to you under the Apache License, Version 2.0 (the
  * "License"); you may not use this file except in compliance
  * with the License.  You may obtain a copy of the License at
  *
  *   http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing,
  * software distributed under the License is distributed on an
  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  *  KIND, either express or implied.  See the License for the
  * specific language governing permissions and limitations
  * under the License.
  */

 #include "celix_properties.h"
 #include "celix_properties_private.h"

 #include "celix_err.h"
 #include "celix_stdlib_cleanup.h"
 #include "celix_utils.h"
 #include "celix_array_list_encoding_private.h"
 #include "celix_json_utils_private.h"

 #include <assert.h>
 #include <jansson.h>
 #include <math.h>
 #include <string.h>

 #define CELIX_PROPERTIES_JSONPATH_SEPARATOR '.'

 static celix_status_t
 celix_properties_decodeValue(celix_properties_t* props, const char* key, json_t* jsonValue, int flags);

 static celix_status_t celix_properties_arrayEntryValueToJson(const char* key,
                                                              const celix_properties_entry_t* entry,
                                                              int flags,
                                                              json_t** out) {
     *out = NULL;
     int encodeArrayFlags = 0;
     if (flags & CELIX_PROPERTIES_ENCODE_ERROR_ON_EMPTY_ARRAYS) {
         encodeArrayFlags |= CELIX_ARRAY_LIST_ENCODE_ERROR_ON_EMPTY_ARRAYS;
     }
     if (flags & CELIX_PROPERTIES_ENCODE_ERROR_ON_NAN_INF) {
         encodeArrayFlags |= CELIX_ARRAY_LIST_ENCODE_ERROR_ON_NAN_INF;
     }
     json_auto_t* array = NULL;
     celix_status_t status = celix_arrayList_encodeToJson(entry->typed.arrayValue, encodeArrayFlags, &array);
     if (status != CELIX_SUCCESS) {
         celix_err_pushf("Failed to encode array list for key %s.", key);
         return status;
     }

     if (json_array_size(array) == 0) {//allow empty arrays, but treat as unset property
         return CELIX_SUCCESS;
     }

     *out = celix_steal_ptr(array);
     return CELIX_SUCCESS;
 }

 static celix_status_t
 celix_properties_entryValueToJson(const char* key, const celix_properties_entry_t* entry, int flags, json_t** out) {
     *out = NULL;
     switch (entry->valueType) {
     case CELIX_PROPERTIES_VALUE_TYPE_STRING:
         *out = json_string(entry->value);
         break;
     case CELIX_PROPERTIES_VALUE_TYPE_LONG:
         *out = json_integer(entry->typed.longValue);
         break;
     case CELIX_PROPERTIES_VALUE_TYPE_DOUBLE:
         if (isnan(entry->typed.doubleValue) || isinf(entry->typed.doubleValue)) {
             if (flags & CELIX_PROPERTIES_ENCODE_ERROR_ON_NAN_INF) {
                 celix_err_pushf("Invalid NaN or Inf in key '%s'.", key);
                 return CELIX_ILLEGAL_ARGUMENT;
             }
             return CELIX_SUCCESS; // ignore NaN and Inf
         }
         *out = json_real(entry->typed.doubleValue);
         break;
     case CELIX_PROPERTIES_VALUE_TYPE_BOOL:
         *out = json_boolean(entry->typed.boolValue);
         break;
     case CELIX_PROPERTIES_VALUE_TYPE_VERSION:
         return celix_utils_versionToJson(entry->typed.versionValue, out);
     case CELIX_PROPERTIES_VALUE_TYPE_ARRAY_LIST:
         return celix_properties_arrayEntryValueToJson(key, entry, flags, out);
     default:
         // LCOV_EXCL_START
         celix_err_pushf("Unexpected properties entry type %d.", entry->valueType);
         return CELIX_ILLEGAL_ARGUMENT;
         // LCOV_EXCL_STOP
     }

     if (!*out) {
         celix_err_pushf("Failed to create json value for key '%s'.", key);
         return ENOMEM;
     }
     return CELIX_SUCCESS;
 }

 static celix_status_t celix_properties_addJsonValueToJson(json_t* value, const char* key, json_t* obj, int flags) {
     if (!value) {
         // ignore unset values
         return CELIX_SUCCESS;
     }

     json_t* field = json_object_get(obj, key);
     if (field) {
         if (flags & CELIX_PROPERTIES_ENCODE_ERROR_ON_COLLISIONS) {
             celix_err_pushf("Invalid key collision. key '%s' already exists.", key);
             json_decref(value);
             return CELIX_ILLEGAL_ARGUMENT;
         }
     }

     int rc = json_object_set_new(obj, key, value);
     if (rc != 0) {
         celix_err_push("Failed to set json object");
         return ENOMEM;
     }
     return CELIX_SUCCESS;
 }

 static celix_status_t celix_properties_addPropertiesEntryFlatToJson(const celix_properties_entry_t* entry,
                                                                     const char* key,
                                                                     json_t* root,
                                                                     int flags) {
     json_t* value;
     celix_status_t status = celix_properties_entryValueToJson(key, entry, flags, &value);
     status = CELIX_DO_IF(status, celix_properties_addJsonValueToJson(value, key, root, flags));
     return status;
 }

 static celix_status_t celix_properties_addPropertiesEntryToJson(const celix_properties_entry_t* entry,
                                                                 const char* key,
                                                                 json_t* root,
                                                                 int flags) {
     json_t* jsonObj = root;
     const char* fieldName = key;
     const char* slash = strchr(key, CELIX_PROPERTIES_JSONPATH_SEPARATOR);
     while (slash) {
         char buf[64];
         char* name = celix_utils_writeOrCreateString(buf, sizeof(buf), "%.*s", (int)(slash - fieldName), fieldName);
         celix_auto(celix_utils_string_guard_t) strGuard = celix_utils_stringGuard_init(buf, name);
         if (!name) {
             celix_err_push("Failed to create name string");
             return ENOMEM;
         }
         json_t* subObj = json_object_get(jsonObj, name);
         if (subObj && !json_is_object(subObj)) {
             if (flags & CELIX_PROPERTIES_ENCODE_ERROR_ON_COLLISIONS) {
                 celix_err_pushf("Invalid key collision. Key '%s' already exists.", name);
                 return CELIX_ILLEGAL_ARGUMENT;
             }
             return CELIX_SUCCESS;
         }
         if (!subObj) {
             subObj = json_object();
             if (!subObj) {
                 celix_err_push("Failed to create json object");
                 return ENOMEM;
             }
             int rc = json_object_set_new(jsonObj, name, subObj);
             if (rc != 0) {
                 celix_err_push("Failed to set json object");
                 return ENOMEM;
             }
         }

         jsonObj = subObj;
         fieldName = slash + 1;
         slash = strchr(fieldName, CELIX_PROPERTIES_JSONPATH_SEPARATOR);
     }

     json_t* value;
     celix_status_t status = celix_properties_entryValueToJson(fieldName, entry, flags, &value);
     if (status != CELIX_SUCCESS) {
         return status;
     }
     return celix_properties_addJsonValueToJson(value, fieldName, jsonObj, flags);
 }

 celix_status_t celix_properties_saveToStream(const celix_properties_t* properties, FILE* stream, int encodeFlags) {
     json_auto_t* root = json_object();
     if (!root) {
         celix_err_push("Failed to create json object");
         return ENOMEM;
     }

     if (!(encodeFlags & CELIX_PROPERTIES_ENCODE_FLAT_STYLE) && !(encodeFlags & CELIX_PROPERTIES_ENCODE_NESTED_STYLE)) {
         //no encoding flags set, default to flat
         encodeFlags |= CELIX_PROPERTIES_ENCODE_FLAT_STYLE;
     }

     CELIX_PROPERTIES_ITERATE(properties, iter) {
         celix_status_t status;
         if (encodeFlags & CELIX_PROPERTIES_ENCODE_FLAT_STYLE) {
             status = celix_properties_addPropertiesEntryFlatToJson(&iter.entry, iter.key, root, encodeFlags);
         } else {
             assert(encodeFlags & CELIX_PROPERTIES_ENCODE_NESTED_STYLE);
             status = celix_properties_addPropertiesEntryToJson(&iter.entry, iter.key, root, encodeFlags);
         }
         if (status != CELIX_SUCCESS) {
             return status;
         }
     }

     size_t jsonFlags = JSON_COMPACT;
     if (encodeFlags & CELIX_PROPERTIES_ENCODE_PRETTY) {
         jsonFlags = JSON_INDENT(2);
     }

     int rc = json_dumpf(root, stream, jsonFlags);
     if (rc != 0) {
         celix_err_push("Failed to dump json object to stream.");
         return CELIX_FILE_IO_EXCEPTION;
     }
     return CELIX_SUCCESS;
 }

 celix_status_t celix_properties_save(const celix_properties_t* properties, const char* filename, int encodeFlags) {
     FILE* stream = fopen(filename, "w");
     if (!stream) {
         celix_err_pushf("Failed to open file %s.", filename);
         return CELIX_FILE_IO_EXCEPTION;
     }
     celix_status_t status = celix_properties_saveToStream(properties, stream, encodeFlags);
     int rc = fclose(stream);
     if (rc != 0) {
         celix_err_pushf("Failed to close file %s: %s", filename, strerror(errno));
         return CELIX_FILE_IO_EXCEPTION;
     }
     return status;
 }

 celix_status_t celix_properties_saveToString(const celix_properties_t* properties, int encodeFlags, char** out) {
     *out = NULL;
     celix_autofree char* buffer = NULL;
     size_t size = 0;
     FILE* stream = open_memstream(&buffer, &size);
     if (!stream) {
         celix_err_push("Failed to open memstream.");
         return ENOMEM;
     }

     celix_status_t status = celix_properties_saveToStream(properties, stream, encodeFlags);
     (void)fclose(stream);
     if (!buffer || status != CELIX_SUCCESS) {
         if (!buffer || status == CELIX_FILE_IO_EXCEPTION) {
             return ENOMEM; // Using memstream as stream, return ENOMEM instead of CELIX_FILE_IO_EXCEPTION
         }
         return status;
     }
     *out = celix_steal_ptr(buffer);
     return CELIX_SUCCESS;
 }

 static celix_status_t
 celix_properties_decodeArray(celix_properties_t* props, const char* key, const json_t* jsonArray, int flags) {
     int decodeArrayFlags = 0;
     if (flags & CELIX_PROPERTIES_DECODE_ERROR_ON_EMPTY_ARRAYS) {
         decodeArrayFlags |= CELIX_ARRAY_LIST_DECODE_ERROR_ON_EMPTY_ARRAYS;
     }
     if (flags & CELIX_PROPERTIES_DECODE_ERROR_ON_UNSUPPORTED_ARRAYS) {
         decodeArrayFlags |= CELIX_ARRAY_LIST_DECODE_ERROR_ON_UNSUPPORTED_ARRAYS;
     }
     celix_autoptr(celix_array_list_t) array = NULL;
     celix_status_t status = celix_arrayList_decodeFromJson(jsonArray, decodeArrayFlags, &array);
     if (status != CELIX_SUCCESS) {
         celix_err_pushf("Failed to decode array list for key '%s'.", key);
         return status;
     }
     if (array == NULL) {
         // ignore empty arrays or mixed type arrays
         return CELIX_SUCCESS;
     }
     return celix_properties_assignArrayList(props, key, celix_steal_ptr(array));
 }

 static celix_status_t
 celix_properties_decodeValue(celix_properties_t* props, const char* key, json_t* jsonValue, int flags) {
     if (strncmp(key, "", 1) == 0) {
         if (flags & CELIX_PROPERTIES_DECODE_ERROR_ON_EMPTY_KEYS) {
             celix_err_push("Key cannot be empty.");
             return CELIX_ILLEGAL_ARGUMENT;
         }
     }

     if (!json_is_object(jsonValue) && celix_properties_hasKey(props, key) &&
         (flags & CELIX_PROPERTIES_DECODE_ERROR_ON_COLLISIONS)) {
         celix_err_pushf("Invalid key collision. Key '%s' already exists.", key);
         return CELIX_ILLEGAL_ARGUMENT;
     }

     celix_status_t status = CELIX_SUCCESS;
     if (celix_utils_isVersionJsonString(jsonValue)) {
         celix_version_t* version;
         status = celix_utils_jsonToVersion(jsonValue, &version);
         status = CELIX_DO_IF(status, celix_properties_assignVersion(props, key, version));
     } else if (json_is_string(jsonValue)) {
         status = celix_properties_setString(props, key, json_string_value(jsonValue));
     } else if (json_is_integer(jsonValue)) {
         status = celix_properties_setLong(props, key, json_integer_value(jsonValue));
     } else if (json_is_real(jsonValue)) {
         status = celix_properties_setDouble(props, key, json_real_value(jsonValue));
     } else if (json_is_boolean(jsonValue)) {
         status = celix_properties_setBool(props, key, json_boolean_value(jsonValue));
     } else if (json_is_object(jsonValue)) {
         const char* fieldName;
         json_t* fieldValue;
         json_object_foreach(jsonValue, fieldName, fieldValue) {
             char buf[64];
             char* combinedKey = celix_utils_writeOrCreateString(buf, sizeof(buf), "%s%c%s", key, CELIX_PROPERTIES_JSONPATH_SEPARATOR, fieldName);
             celix_auto(celix_utils_string_guard_t) strGuard = celix_utils_stringGuard_init(buf, combinedKey);
             if (!combinedKey) {
                 celix_err_push("Failed to create sub key.");
                 return ENOMEM;
             }
             status = celix_properties_decodeValue(props, combinedKey, fieldValue, flags);
             if (status != CELIX_SUCCESS) {
                 return status;
             }
         }
         return CELIX_SUCCESS;
     } else if (json_is_array(jsonValue)) {
         status = celix_properties_decodeArray(props, key, jsonValue, flags);
     } else if (json_is_null(jsonValue)) {
         if (flags & CELIX_PROPERTIES_DECODE_ERROR_ON_NULL_VALUES) {
             celix_err_pushf("Invalid null value for key '%s'.", key);
             return CELIX_ILLEGAL_ARGUMENT;
         }
         // ignore null values
         return CELIX_SUCCESS;
     } else {
         // LCOV_EXCL_START
         celix_err_pushf("Unexpected json value type for key '%s'.", key);
         return CELIX_ILLEGAL_ARGUMENT;
         // LCOV_EXCL_STOP
     }
     return status;
 }

 static celix_status_t celix_properties_decodeFromJson(json_t* obj, int flags, celix_properties_t** out) {
     *out = NULL;
     if (!json_is_object(obj)) {
         celix_err_push("Expected json object.");
         return CELIX_ILLEGAL_ARGUMENT;
     }

     celix_autoptr(celix_properties_t) props = celix_properties_create();
     if (!props) {
         return ENOMEM;
     }

     const char* key;
     json_t* value;
     json_object_foreach(obj, key, value) {
         celix_status_t status = celix_properties_decodeValue(props, key, value, flags);
         if (status != CELIX_SUCCESS) {
             return status;
         }
     }

     *out = celix_steal_ptr(props);
     return CELIX_SUCCESS;
 }

 celix_status_t celix_properties_loadFromStream(FILE* stream, int decodeFlags, celix_properties_t** out) {
     json_error_t jsonError;
     size_t jsonFlags = 0;
     if (decodeFlags & CELIX_PROPERTIES_DECODE_ERROR_ON_DUPLICATES) {
         jsonFlags = JSON_REJECT_DUPLICATES;
     }
     json_auto_t* root = json_loadf(stream, jsonFlags, &jsonError);
     if (!root) {
         celix_err_pushf("Failed to parse json from %s:%i:%i: %s.",
                         jsonError.source,
                         jsonError.line,
                         jsonError.column,
                         jsonError.text);
         return celix_utils_jsonErrorToStatus(json_error_code(&jsonError));
     }
     return celix_properties_decodeFromJson(root, decodeFlags, out);
 }

 celix_status_t celix_properties_load(const char* filename, int decodeFlags, celix_properties_t** out) {
     FILE* stream = fopen(filename, "r");
     if (!stream) {
         celix_err_pushf("Failed to open file %s.", filename);
         return CELIX_FILE_IO_EXCEPTION;
     }
     celix_status_t status = celix_properties_loadFromStream(stream, decodeFlags, out);
     fclose(stream);
     return status;
 }

 celix_status_t celix_properties_loadFromString(const char* input, int decodeFlags, celix_properties_t** out) {
     FILE* stream = fmemopen((void*)input, strlen(input), "r");
     if (!stream) {
         celix_err_push("Failed to open memstream.");
         return ENOMEM;
     }
     celix_status_t status = celix_properties_loadFromStream(stream, decodeFlags, out);
     fclose(stream);
     return status;
 }
	/*
	* Licensed to the Apache Software Foundation (ASF) under one
	* or more contributor license agreements. See the NOTICE file
	* distributed with this work for additional information
	* regarding copyright ownership. The ASF licenses this file
	* to you under the Apache License, Version 2.0 (the
	* "License"); you may not use this file except in compliance
	* with the License. You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing,
	* software distributed under the License is distributed on an
	* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
	* KIND, either express or implied. See the License for the
	* specific language governing permissions and limitations
	* under the License.
	*/

	#include "celix_properties.h"
	#include "celix_properties_private.h"

	#include "celix_err.h"
	#include "celix_stdlib_cleanup.h"
	#include "celix_utils.h"
	#include "celix_array_list_encoding_private.h"
	#include "celix_json_utils_private.h"

	#include <assert.h>
	#include <jansson.h>
	#include <math.h>
	#include <string.h>

	#define CELIX_PROPERTIES_JSONPATH_SEPARATOR '.'

	static celix_status_t
	celix_properties_decodeValue(celix_properties_t* props, const char* key, json_t* jsonValue, int flags);

	static celix_status_t celix_properties_arrayEntryValueToJson(const char* key,
	const celix_properties_entry_t* entry,
	int flags,
	json_t** out) {
	*out = NULL;
	int encodeArrayFlags = 0;
	if (flags & CELIX_PROPERTIES_ENCODE_ERROR_ON_EMPTY_ARRAYS) {
	encodeArrayFlags \|= CELIX_ARRAY_LIST_ENCODE_ERROR_ON_EMPTY_ARRAYS;
	}
	if (flags & CELIX_PROPERTIES_ENCODE_ERROR_ON_NAN_INF) {
	encodeArrayFlags \|= CELIX_ARRAY_LIST_ENCODE_ERROR_ON_NAN_INF;
	}
	json_auto_t* array = NULL;
	celix_status_t status = celix_arrayList_encodeToJson(entry->typed.arrayValue, encodeArrayFlags, &array);
	if (status != CELIX_SUCCESS) {
	celix_err_pushf("Failed to encode array list for key %s.", key);
	return status;
	}

	if (json_array_size(array) == 0) {//allow empty arrays, but treat as unset property
	return CELIX_SUCCESS;
	}

	*out = celix_steal_ptr(array);
	return CELIX_SUCCESS;
	}

	static celix_status_t
	celix_properties_entryValueToJson(const char* key, const celix_properties_entry_t* entry, int flags, json_t** out) {
	*out = NULL;
	switch (entry->valueType) {
	case CELIX_PROPERTIES_VALUE_TYPE_STRING:
	*out = json_string(entry->value);
	break;
	case CELIX_PROPERTIES_VALUE_TYPE_LONG:
	*out = json_integer(entry->typed.longValue);
	break;
	case CELIX_PROPERTIES_VALUE_TYPE_DOUBLE:
	if (isnan(entry->typed.doubleValue) \|\| isinf(entry->typed.doubleValue)) {
	if (flags & CELIX_PROPERTIES_ENCODE_ERROR_ON_NAN_INF) {
	celix_err_pushf("Invalid NaN or Inf in key '%s'.", key);
	return CELIX_ILLEGAL_ARGUMENT;
	}
	return CELIX_SUCCESS; // ignore NaN and Inf
	}
	*out = json_real(entry->typed.doubleValue);
	break;
	case CELIX_PROPERTIES_VALUE_TYPE_BOOL:
	*out = json_boolean(entry->typed.boolValue);
	break;
	case CELIX_PROPERTIES_VALUE_TYPE_VERSION:
	return celix_utils_versionToJson(entry->typed.versionValue, out);
	case CELIX_PROPERTIES_VALUE_TYPE_ARRAY_LIST:
	return celix_properties_arrayEntryValueToJson(key, entry, flags, out);
	default:
	// LCOV_EXCL_START
	celix_err_pushf("Unexpected properties entry type %d.", entry->valueType);
	return CELIX_ILLEGAL_ARGUMENT;
	// LCOV_EXCL_STOP
	}

	if (!*out) {
	celix_err_pushf("Failed to create json value for key '%s'.", key);
	return ENOMEM;
	}
	return CELIX_SUCCESS;
	}

	static celix_status_t celix_properties_addJsonValueToJson(json_t* value, const char* key, json_t* obj, int flags) {
	if (!value) {
	// ignore unset values
	return CELIX_SUCCESS;
	}

	json_t* field = json_object_get(obj, key);
	if (field) {
	if (flags & CELIX_PROPERTIES_ENCODE_ERROR_ON_COLLISIONS) {
	celix_err_pushf("Invalid key collision. key '%s' already exists.", key);
	json_decref(value);
	return CELIX_ILLEGAL_ARGUMENT;
	}
	}

	int rc = json_object_set_new(obj, key, value);
	if (rc != 0) {
	celix_err_push("Failed to set json object");
	return ENOMEM;
	}
	return CELIX_SUCCESS;
	}

	static celix_status_t celix_properties_addPropertiesEntryFlatToJson(const celix_properties_entry_t* entry,
	const char* key,
	json_t* root,
	int flags) {
	json_t* value;
	celix_status_t status = celix_properties_entryValueToJson(key, entry, flags, &value);
	status = CELIX_DO_IF(status, celix_properties_addJsonValueToJson(value, key, root, flags));
	return status;
	}

	static celix_status_t celix_properties_addPropertiesEntryToJson(const celix_properties_entry_t* entry,
	const char* key,
	json_t* root,
	int flags) {
	json_t* jsonObj = root;
	const char* fieldName = key;
	const char* slash = strchr(key, CELIX_PROPERTIES_JSONPATH_SEPARATOR);
	while (slash) {
	char buf[64];
	char* name = celix_utils_writeOrCreateString(buf, sizeof(buf), "%.*s", (int)(slash - fieldName), fieldName);
	celix_auto(celix_utils_string_guard_t) strGuard = celix_utils_stringGuard_init(buf, name);
	if (!name) {
	celix_err_push("Failed to create name string");
	return ENOMEM;
	}
	json_t* subObj = json_object_get(jsonObj, name);
	if (subObj && !json_is_object(subObj)) {
	if (flags & CELIX_PROPERTIES_ENCODE_ERROR_ON_COLLISIONS) {
	celix_err_pushf("Invalid key collision. Key '%s' already exists.", name);
	return CELIX_ILLEGAL_ARGUMENT;
	}
	return CELIX_SUCCESS;
	}
	if (!subObj) {
	subObj = json_object();
	if (!subObj) {
	celix_err_push("Failed to create json object");
	return ENOMEM;
	}
	int rc = json_object_set_new(jsonObj, name, subObj);
	if (rc != 0) {
	celix_err_push("Failed to set json object");
	return ENOMEM;
	}
	}

	jsonObj = subObj;
	fieldName = slash + 1;
	slash = strchr(fieldName, CELIX_PROPERTIES_JSONPATH_SEPARATOR);
	}

	json_t* value;
	celix_status_t status = celix_properties_entryValueToJson(fieldName, entry, flags, &value);
	if (status != CELIX_SUCCESS) {
	return status;
	}
	return celix_properties_addJsonValueToJson(value, fieldName, jsonObj, flags);
	}

	celix_status_t celix_properties_saveToStream(const celix_properties_t* properties, FILE* stream, int encodeFlags) {
	json_auto_t* root = json_object();
	if (!root) {
	celix_err_push("Failed to create json object");
	return ENOMEM;
	}

	if (!(encodeFlags & CELIX_PROPERTIES_ENCODE_FLAT_STYLE) && !(encodeFlags & CELIX_PROPERTIES_ENCODE_NESTED_STYLE)) {
	//no encoding flags set, default to flat
	encodeFlags \|= CELIX_PROPERTIES_ENCODE_FLAT_STYLE;
	}

	CELIX_PROPERTIES_ITERATE(properties, iter) {
	celix_status_t status;
	if (encodeFlags & CELIX_PROPERTIES_ENCODE_FLAT_STYLE) {
	status = celix_properties_addPropertiesEntryFlatToJson(&iter.entry, iter.key, root, encodeFlags);
	} else {
	assert(encodeFlags & CELIX_PROPERTIES_ENCODE_NESTED_STYLE);
	status = celix_properties_addPropertiesEntryToJson(&iter.entry, iter.key, root, encodeFlags);
	}
	if (status != CELIX_SUCCESS) {
	return status;
	}
	}

	size_t jsonFlags = JSON_COMPACT;
	if (encodeFlags & CELIX_PROPERTIES_ENCODE_PRETTY) {
	jsonFlags = JSON_INDENT(2);
	}

	int rc = json_dumpf(root, stream, jsonFlags);
	if (rc != 0) {
	celix_err_push("Failed to dump json object to stream.");
	return CELIX_FILE_IO_EXCEPTION;
	}
	return CELIX_SUCCESS;
	}

	celix_status_t celix_properties_save(const celix_properties_t* properties, const char* filename, int encodeFlags) {
	FILE* stream = fopen(filename, "w");
	if (!stream) {
	celix_err_pushf("Failed to open file %s.", filename);
	return CELIX_FILE_IO_EXCEPTION;
	}
	celix_status_t status = celix_properties_saveToStream(properties, stream, encodeFlags);
	int rc = fclose(stream);
	if (rc != 0) {
	celix_err_pushf("Failed to close file %s: %s", filename, strerror(errno));
	return CELIX_FILE_IO_EXCEPTION;
	}
	return status;
	}

	celix_status_t celix_properties_saveToString(const celix_properties_t* properties, int encodeFlags, char** out) {
	*out = NULL;
	celix_autofree char* buffer = NULL;
	size_t size = 0;
	FILE* stream = open_memstream(&buffer, &size);
	if (!stream) {
	celix_err_push("Failed to open memstream.");
	return ENOMEM;
	}

	celix_status_t status = celix_properties_saveToStream(properties, stream, encodeFlags);
	(void)fclose(stream);
	if (!buffer \|\| status != CELIX_SUCCESS) {
	if (!buffer \|\| status == CELIX_FILE_IO_EXCEPTION) {
	return ENOMEM; // Using memstream as stream, return ENOMEM instead of CELIX_FILE_IO_EXCEPTION
	}
	return status;
	}
	*out = celix_steal_ptr(buffer);
	return CELIX_SUCCESS;
	}

	static celix_status_t
	celix_properties_decodeArray(celix_properties_t* props, const char* key, const json_t* jsonArray, int flags) {
	int decodeArrayFlags = 0;
	if (flags & CELIX_PROPERTIES_DECODE_ERROR_ON_EMPTY_ARRAYS) {
	decodeArrayFlags \|= CELIX_ARRAY_LIST_DECODE_ERROR_ON_EMPTY_ARRAYS;
	}
	if (flags & CELIX_PROPERTIES_DECODE_ERROR_ON_UNSUPPORTED_ARRAYS) {
	decodeArrayFlags \|= CELIX_ARRAY_LIST_DECODE_ERROR_ON_UNSUPPORTED_ARRAYS;
	}
	celix_autoptr(celix_array_list_t) array = NULL;
	celix_status_t status = celix_arrayList_decodeFromJson(jsonArray, decodeArrayFlags, &array);
	if (status != CELIX_SUCCESS) {
	celix_err_pushf("Failed to decode array list for key '%s'.", key);
	return status;
	}
	if (array == NULL) {
	// ignore empty arrays or mixed type arrays
	return CELIX_SUCCESS;
	}
	return celix_properties_assignArrayList(props, key, celix_steal_ptr(array));
	}

	static celix_status_t
	celix_properties_decodeValue(celix_properties_t* props, const char* key, json_t* jsonValue, int flags) {
	if (strncmp(key, "", 1) == 0) {
	if (flags & CELIX_PROPERTIES_DECODE_ERROR_ON_EMPTY_KEYS) {
	celix_err_push("Key cannot be empty.");
	return CELIX_ILLEGAL_ARGUMENT;
	}
	}

	if (!json_is_object(jsonValue) && celix_properties_hasKey(props, key) &&
	(flags & CELIX_PROPERTIES_DECODE_ERROR_ON_COLLISIONS)) {
	celix_err_pushf("Invalid key collision. Key '%s' already exists.", key);
	return CELIX_ILLEGAL_ARGUMENT;
	}

	celix_status_t status = CELIX_SUCCESS;
	if (celix_utils_isVersionJsonString(jsonValue)) {
	celix_version_t* version;
	status = celix_utils_jsonToVersion(jsonValue, &version);
	status = CELIX_DO_IF(status, celix_properties_assignVersion(props, key, version));
	} else if (json_is_string(jsonValue)) {
	status = celix_properties_setString(props, key, json_string_value(jsonValue));
	} else if (json_is_integer(jsonValue)) {
	status = celix_properties_setLong(props, key, json_integer_value(jsonValue));
	} else if (json_is_real(jsonValue)) {
	status = celix_properties_setDouble(props, key, json_real_value(jsonValue));
	} else if (json_is_boolean(jsonValue)) {
	status = celix_properties_setBool(props, key, json_boolean_value(jsonValue));
	} else if (json_is_object(jsonValue)) {
	const char* fieldName;
	json_t* fieldValue;
	json_object_foreach(jsonValue, fieldName, fieldValue) {
	char buf[64];
	char* combinedKey = celix_utils_writeOrCreateString(buf, sizeof(buf), "%s%c%s", key, CELIX_PROPERTIES_JSONPATH_SEPARATOR, fieldName);
	celix_auto(celix_utils_string_guard_t) strGuard = celix_utils_stringGuard_init(buf, combinedKey);
	if (!combinedKey) {
	celix_err_push("Failed to create sub key.");
	return ENOMEM;
	}
	status = celix_properties_decodeValue(props, combinedKey, fieldValue, flags);
	if (status != CELIX_SUCCESS) {
	return status;
	}
	}
	return CELIX_SUCCESS;
	} else if (json_is_array(jsonValue)) {
	status = celix_properties_decodeArray(props, key, jsonValue, flags);
	} else if (json_is_null(jsonValue)) {
	if (flags & CELIX_PROPERTIES_DECODE_ERROR_ON_NULL_VALUES) {
	celix_err_pushf("Invalid null value for key '%s'.", key);
	return CELIX_ILLEGAL_ARGUMENT;
	}
	// ignore null values
	return CELIX_SUCCESS;
	} else {
	// LCOV_EXCL_START
	celix_err_pushf("Unexpected json value type for key '%s'.", key);
	return CELIX_ILLEGAL_ARGUMENT;
	// LCOV_EXCL_STOP
	}
	return status;
	}

	static celix_status_t celix_properties_decodeFromJson(json_t* obj, int flags, celix_properties_t** out) {
	*out = NULL;
	if (!json_is_object(obj)) {
	celix_err_push("Expected json object.");
	return CELIX_ILLEGAL_ARGUMENT;
	}

	celix_autoptr(celix_properties_t) props = celix_properties_create();
	if (!props) {
	return ENOMEM;
	}

	const char* key;
	json_t* value;
	json_object_foreach(obj, key, value) {
	celix_status_t status = celix_properties_decodeValue(props, key, value, flags);
	if (status != CELIX_SUCCESS) {
	return status;
	}
	}

	*out = celix_steal_ptr(props);
	return CELIX_SUCCESS;
	}

	celix_status_t celix_properties_loadFromStream(FILE* stream, int decodeFlags, celix_properties_t** out) {
	json_error_t jsonError;
	size_t jsonFlags = 0;
	if (decodeFlags & CELIX_PROPERTIES_DECODE_ERROR_ON_DUPLICATES) {
	jsonFlags = JSON_REJECT_DUPLICATES;
	}
	json_auto_t* root = json_loadf(stream, jsonFlags, &jsonError);
	if (!root) {
	celix_err_pushf("Failed to parse json from %s:%i:%i: %s.",
	jsonError.source,
	jsonError.line,
	jsonError.column,
	jsonError.text);
	return celix_utils_jsonErrorToStatus(json_error_code(&jsonError));
	}
	return celix_properties_decodeFromJson(root, decodeFlags, out);
	}

	celix_status_t celix_properties_load(const char* filename, int decodeFlags, celix_properties_t** out) {
	FILE* stream = fopen(filename, "r");
	if (!stream) {
	celix_err_pushf("Failed to open file %s.", filename);
	return CELIX_FILE_IO_EXCEPTION;
	}
	celix_status_t status = celix_properties_loadFromStream(stream, decodeFlags, out);
	fclose(stream);
	return status;
	}

	celix_status_t celix_properties_loadFromString(const char* input, int decodeFlags, celix_properties_t** out) {
	FILE* stream = fmemopen((void*)input, strlen(input), "r");
	if (!stream) {
	celix_err_push("Failed to open memstream.");
	return ENOMEM;
	}
	celix_status_t status = celix_properties_loadFromStream(stream, decodeFlags, out);
	fclose(stream);
	return status;
	}