From 22330623cd3a26b487d94b49e065439af1b79816 Mon Sep 17 00:00:00 2001 From: Kevin Day Date: Thu, 19 May 2022 00:56:28 -0500 Subject: [PATCH] Update: Rewrite the f_serialize functions. The code is outdated and needs to be updated with the current practices. I remember being uncertain on what to name several of these functions. I didn't want an f_unserialize function because that would require a separate project (even if the naming makes sense). Perhaps I may do that in the future, but for now just use the words "from" and "to". --- level_0/f_serialize/c/private-serialize.c | 39 +++-- level_0/f_serialize/c/private-serialize.h | 18 +- level_0/f_serialize/c/serialize.c | 278 +++++++++++++++++------------- level_0/f_serialize/c/serialize.h | 158 ++++++++++------- level_0/f_serialize/c/serialize/common.c | 4 +- level_0/f_serialize/c/serialize/common.h | 12 +- 6 files changed, 287 insertions(+), 222 deletions(-) diff --git a/level_0/f_serialize/c/private-serialize.c b/level_0/f_serialize/c/private-serialize.c index 2a19e0d..9c83501 100644 --- a/level_0/f_serialize/c/private-serialize.c +++ b/level_0/f_serialize/c/private-serialize.c @@ -5,30 +5,27 @@ extern "C" { #endif -#if !defined(_di_f_serialize_un_simple_find_) || !defined(_di_f_serialize_un_simple_get_) - f_status_t private_f_serialize_un_simple_find(const f_string_static_t serialize, const f_array_length_t index, f_string_range_t * const location) { +#if !defined(_di_f_serialize_from_simple_get_) || !defined(_di_f_serialize_from_simple_select_) + f_status_t private_f_serialize_from_simple_select(const f_string_static_t source, const f_array_length_t index, f_string_range_t * const range) { - f_array_length_t i = 0; f_array_length_t start = 0; f_array_length_t current = 0; unsigned short width = 0; - for (; i < serialize.used; i += width) { + for (f_array_length_t i = 0; i < source.used; i += width) { - width = macro_f_utf_byte_width(serialize.string[i]); + width = macro_f_utf_byte_width(source.string[i]); - if (serialize.string[i] == f_serialize_simple_splitter_s.string[0]) { + if (source.string[i] == f_serialize_to_simple_splitter_s.string[0]) { if (current == index) { if (start == i) { - - // provide an invalid start to stop range to communicate that there is no data. - location->start = 1; - location->stop = 0; + range->start = 1; + range->stop = 0; } else { - location->start = start; - location->stop = i - 1; + range->start = start; + range->stop = i - 1; } return F_none; @@ -36,24 +33,32 @@ extern "C" { start = i + width; ++current; + + // Handle case when splitter as at the end of the string, creating a new empty string. + if (start >= source.used && current == index) { + range->start = 1; + range->stop = 0; + + return F_none; + } } - else if (i == serialize.used) { + else if (i == source.used) { if (current == index) { - location->start = start; - location->stop = i - 1; + range->start = start; + range->stop = i - 1; } return F_none_eos; } - if (i + width > serialize.used) { + if (i + width > source.used) { return F_status_set_error(F_complete_not_utf_eos); } } // for return F_data_not_eos; } -#endif // !defined(_di_f_serialize_un_simple_find_) || !defined(_di_f_serialize_un_simple_get_) +#endif // !defined(_di_f_serialize_from_simple_get_) || !defined(_di_f_serialize_from_simple_select_) #ifdef __cplusplus } // extern "C" diff --git a/level_0/f_serialize/c/private-serialize.h b/level_0/f_serialize/c/private-serialize.h index 2bf9848..400a1e7 100644 --- a/level_0/f_serialize/c/private-serialize.h +++ b/level_0/f_serialize/c/private-serialize.h @@ -16,16 +16,16 @@ extern "C" { #endif /** - * Private implementation of f_serialize_un_simple_get(). + * Private implementation of f_serialize_from_simple_get(). * * Intended to be shared to each of the different implementation variations. * - * @param serialize - * A serialize string to de-serialize. + * @param source + * A serialized string to de-serialize. * @param index - * An index position within the serialize string to get the deserialize positions of. - * @param location - * A location within the serialize string representing the string at the given index. + * The selected position within the serialize string to get the deserialize positions of. + * @param range + * A range within the serialize string representing the string at the given index. * * @return * F_none on success. @@ -35,9 +35,9 @@ extern "C" { * F_complete_not_utf_eos (with error bit) if end of string is reached before a complete UTF-8 character can be processed. * F_parameter (with error bit) if a parameter is invalid. */ -#if !defined(_di_f_serialize_un_simple_find_) || !defined(_di_f_serialize_un_simple_get_) - extern f_status_t private_f_serialize_un_simple_find(const f_string_static_t serialize, const f_array_length_t index, f_string_range_t * const location) F_attribute_visibility_internal_d; -#endif // !defined(_di_f_serialize_un_simple_find_) || !defined(_di_f_serialize_un_simple_get_) +#if !defined(_di_f_serialize_from_simple_get_) || !defined(_di_f_serialize_from_simple_select_) + extern f_status_t private_f_serialize_from_simple_select(const f_string_static_t source, const f_array_length_t index, f_string_range_t * const range) F_attribute_visibility_internal_d; +#endif // !defined(_di_f_serialize_from_simple_get_) || !defined(_di_f_serialize_from_simple_select_) #ifdef __cplusplus } // extern "C" diff --git a/level_0/f_serialize/c/serialize.c b/level_0/f_serialize/c/serialize.c index bb45337..8cee1b6 100644 --- a/level_0/f_serialize/c/serialize.c +++ b/level_0/f_serialize/c/serialize.c @@ -5,201 +5,231 @@ extern "C" { #endif -#ifndef _di_f_serialize_simple_ - f_status_t f_serialize_simple(const f_string_static_t value, f_string_dynamic_t * const serialize) { +#ifndef _di_f_serialize_from_simple_ + f_status_t f_serialize_from_simple(const f_string_static_t source, f_string_dynamics_t * const destination) { #ifndef _di_level_0_parameter_checking_ - if (!serialize) return F_status_set_error(F_parameter); + if (!destination) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ + if (!source.used) return F_data_not; + f_status_t status = F_none; + f_array_length_t i = 0; + f_array_length_t start = 0; + f_array_length_t total = 0; + uint8_t width = 0; - if (serialize->used + value.used + 1 >= serialize->size) { - status = f_string_dynamic_resize(serialize->size + value.used + 1, serialize); - if (F_status_is_error(status)) return status; - } + do { + width = macro_f_utf_byte_width(source.string[i]); - if (!serialize->used) { - memcpy(serialize->string + serialize->used, value.string, sizeof(f_char_t) * value.used); - serialize->used += value.used; - } - else { - memcpy(serialize->string + serialize->used, f_serialize_simple_splitter_s.string, sizeof(f_char_t) * f_serialize_simple_splitter_s.used); - memcpy(serialize->string + serialize->used + f_serialize_simple_splitter_s.used, value.string, sizeof(f_char_t) * value.used); - serialize->used += value.used + 1; - } + if (i + width > source.used) { + total = i - start; - return F_none; - } -#endif // _di_f_serialize_simple_ + status = f_string_dynamics_increase(F_memory_default_allocation_small_d, destination); + if (F_status_is_error(status)) return status; -#ifndef _di_f_serialize_un_simple_ - f_status_t f_serialize_un_simple(const f_string_static_t serialize, f_string_dynamics_t * const strings) { - #ifndef _di_level_0_parameter_checking_ - if (!serialize.used) return F_status_set_error(F_parameter); - if (!strings) return F_status_set_error(F_parameter); - #endif // _di_level_0_parameter_checking_ + destination->array[destination->used].used = 0; - f_status_t status = F_none; + status = f_string_append(source.string + start, total, &destination->array[destination->used]); + if (F_status_is_error(status)) return status; - f_array_length_t i = 0; - f_array_length_t start = 0; + ++destination->used; - uint8_t width = 0; + return F_complete_not_utf_eos; + } + + if (source.string[i] == f_serialize_to_simple_splitter_s.string[0]) { + total = i - start; - while (i < serialize.used) { + status = f_string_dynamics_increase(F_memory_default_allocation_small_d, destination); + if (F_status_is_error(status)) return status; - width = macro_f_utf_byte_width(serialize.string[i]); + destination->array[destination->used].used = 0; - if (serialize.string[i] == f_serialize_simple_splitter_s.string[0] || i + 1 >= serialize.used) { - macro_f_memory_structure_increment(status, (*strings), 1, F_memory_default_allocation_small_d, macro_f_string_dynamics_t_resize, F_array_too_large); + status = f_string_append(source.string + start, total, &destination->array[destination->used]); if (F_status_is_error(status)) return status; - if (start == i) { - strings->array[strings->used].used = 0; - ++strings->used; + ++destination->used; + start = i + width; + + // Handle case when splitter as at the end of the string, creating a new empty string. + if (start == source.used) { + status = f_string_dynamics_increase(F_memory_default_allocation_small_d, destination); + if (F_status_is_error(status)) return status; + + destination->array[++destination->used].used = 0; } - else { - f_array_length_t total; + } - if (i + 1 >= serialize.used) { - total = (i - start) + 1; - } - else { + i += width; - // subtract one from stop point to disclused the f_serialize_simple_splitter_s character. - total = ((i - 1) - start) + 1; - } + } while (i < source.used); - if (total > strings->array[strings->used].size) { - macro_f_string_dynamic_t_clear(strings->array[strings->used]) + if (start < source.used) { + total = source.used - start; - status = f_string_dynamic_resize(total, &strings->array[strings->used]); - if (F_status_is_error(status)) return status; + status = f_string_dynamics_increase(F_memory_default_allocation_small_d, destination); + if (F_status_is_error(status)) return status; - strings->array[strings->used].size = total; - } + destination->array[destination->used].used = 0; - memcpy(strings->array[strings->used].string, serialize.string + start, sizeof(f_char_t) * total); + status = f_string_append(source.string + start, total, &destination->array[destination->used]); + if (F_status_is_error(status)) return status; - strings->array[strings->used].used = total; - ++strings->used; - } + ++destination->used; + } - if (i + width > serialize.used) { - return F_status_set_error(F_complete_not_utf_eos); - } + return F_none; + } +#endif // _di_f_serialize_from_simple_ - start = i + width; - } - else if (i + width > serialize.used) { - return F_status_set_error(F_complete_not_utf_eos); - } +#ifndef _di_f_serialize_from_simple_get_ + f_status_t f_serialize_from_simple_get(const f_string_static_t source, const f_array_length_t index, f_string_dynamic_t * const destination) { + #ifndef _di_level_0_parameter_checking_ + if (!destination) return F_status_set_error(F_parameter); + #endif // _di_level_0_parameter_checking_ - i += width; - } // while + if (!source.used) return F_data_not; - return F_none; + f_string_range_t range = f_string_range_t_initialize; + + f_status_t status = private_f_serialize_from_simple_select(source, index, &range); + if (F_status_is_error(status)) return status; + + if (status == F_data_not_eos) { + return status; + } + + const f_array_length_t total = (range.stop - range.start) + 1; + + if (range.start <= range.stop) { + const f_status_t status_allocation = f_string_append(source.string + range.start, total, destination); + if (F_status_is_error(status_allocation)) return status_allocation; + } + + return status; } -#endif // _di_f_serialize_un_simple_ +#endif // _di_f_serialize_from_simple_get_ -#ifndef _di_f_serialize_un_simple_map_ - f_status_t f_serialize_un_simple_map(const f_string_static_t serialize, f_string_ranges_t * const locations) { +#ifndef _di_f_serialize_from_simple_range_ + f_status_t f_serialize_from_simple_range(const f_string_static_t source, f_string_ranges_t * const ranges) { #ifndef _di_level_0_parameter_checking_ - if (!serialize.used) return F_status_set_error(F_parameter); - if (!locations) return F_status_set_error(F_parameter); + if (!ranges) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ - f_status_t status = F_none; + if (!source.used) return F_data_not; + f_status_t status = F_none; f_array_length_t i = 0; f_array_length_t start = 0; - + f_array_length_t total = 0; uint8_t width = 0; - for (; i < serialize.used; i += width) { + do { + width = macro_f_utf_byte_width(source.string[i]); - width = macro_f_utf_byte_width(serialize.string[i]); + if (i + width > source.used) { + total = i - start; - if (serialize.string[i] == f_serialize_simple_splitter_s.string[0] || i + 1 >= serialize.used) { - macro_f_memory_structure_increment(status, (*locations), 1, F_memory_default_allocation_small_d, macro_f_string_ranges_t_resize, F_array_too_large); + status = f_string_ranges_increase(F_memory_default_allocation_small_d, ranges); if (F_status_is_error(status)) return status; - if (start == i) { - - // provide an invalid start to stop range to communicate that there is no data. - locations->array[locations->used].start = 1; - locations->array[locations->used].stop = 0; - } - else if (i + 1 >= serialize.used) { - locations->array[locations->used].start = start; - locations->array[locations->used].stop = i; + if (total) { + ranges->array[ranges->used].start = start; + ranges->array[ranges->used++].stop = start + (total - 1); } else { - - // subtract one from stop point to disclused the f_serialize_simple_splitter_s character. - locations->array[locations->used].start = start; - locations->array[locations->used].stop = i - 1; + ranges->array[ranges->used].start = 1; + ranges->array[ranges->used++].stop = 0; } - ++locations->used; + return F_complete_not_utf_eos; + } + + if (source.string[i] == f_serialize_to_simple_splitter_s.string[0]) { + total = i - start; - if (i + width > serialize.used) { - return F_status_set_error(F_complete_not_utf_eos); + status = f_string_ranges_increase(F_memory_default_allocation_small_d, ranges); + if (F_status_is_error(status)) return status; + + if (total) { + ranges->array[ranges->used].start = start; + ranges->array[ranges->used++].stop = start + (total - 1); + } + else { + ranges->array[ranges->used].start = 1; + ranges->array[ranges->used++].stop = 0; } start = i + width; + + // Handle case when splitter as at the end of the string, creating a new empty string. + if (start == source.used) { + status = f_string_ranges_increase(F_memory_default_allocation_small_d, ranges); + if (F_status_is_error(status)) return status; + + ranges->array[ranges->used].start = 1; + ranges->array[ranges->used++].stop = 0; + } + } + + i += width; + + } while (i < source.used); + + if (start < source.used) { + total = source.used - start; + + status = f_string_ranges_increase(F_memory_default_allocation_small_d, ranges); + if (F_status_is_error(status)) return status; + + if (total) { + ranges->array[ranges->used].start = start; + ranges->array[ranges->used++].stop = start + (total - 1); } - else if (i + width > serialize.used) { - return F_status_set_error(F_complete_not_utf_eos); + else { + ranges->array[ranges->used].start = 1; + ranges->array[ranges->used++].stop = 0; } - } // for + } return F_none; } -#endif // _di_f_serialize_un_simple_map_ +#endif // _di_f_serialize_from_simple_range_ -#ifndef _di_f_serialize_un_simple_find_ - f_status_t f_serialize_un_simple_find(const f_string_static_t serialize, const f_array_length_t index, f_string_range_t * const range) { +#ifndef _di_f_serialize_from_simple_select_ + f_status_t f_serialize_from_simple_select(const f_string_static_t source, const f_array_length_t index, f_string_range_t * const range) { #ifndef _di_level_0_parameter_checking_ - if (!serialize.used) return F_status_set_error(F_parameter); if (!range) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ - return private_f_serialize_un_simple_find(serialize, index, range); + if (!source.used) return F_data_not; + + return private_f_serialize_from_simple_select(source, index, range); } -#endif // _di_f_serialize_un_simple_find_ +#endif // _di_f_serialize_from_simple_select_ -#ifndef _di_f_serialize_un_simple_get_ - f_status_t f_serialize_un_simple_get(const f_string_static_t serialize, const f_array_length_t index, f_string_dynamic_t * const dynamic) { +#ifndef _di_f_serialize_to_simple_ + f_status_t f_serialize_to_simple(const f_string_static_t source, f_string_dynamic_t * const destination) { #ifndef _di_level_0_parameter_checking_ - if (!serialize.used) return F_status_set_error(F_parameter); - if (!dynamic) return F_status_set_error(F_parameter); + if (!destination) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ - f_string_range_t range = f_string_range_t_initialize; - - f_status_t status = private_f_serialize_un_simple_find(serialize, index, &range); - if (F_status_is_error(status)) return status; + if (!source.used) return F_data_not; - if (status == F_data_not_eos) { - dynamic->used = 0; - - return status; - } - - f_array_length_t total = (range.stop - range.start) + 1; + f_status_t status = F_none; - if (total >= dynamic->size) { - const f_status_t status_allocation = f_string_dynamic_resize(total, dynamic); - if (F_status_is_error(status_allocation)) return status_allocation; + if (destination->used) { + status = f_string_dynamic_append_assure(f_serialize_to_simple_splitter_s, destination); + if (F_status_is_error(status)) return status; } - memcpy(dynamic->string, serialize.string + range.start, sizeof(f_char_t) * total); - dynamic->used = total; + status = f_string_dynamic_append(source, destination); + if (F_status_is_error(status)) return status; - return status; + return F_none; } -#endif // _di_f_serialize_un_simple_get_ +#endif // _di_f_serialize_to_simple_ #ifdef __cplusplus } // extern "C" diff --git a/level_0/f_serialize/c/serialize.h b/level_0/f_serialize/c/serialize.h index 677aad0..6f0526d 100644 --- a/level_0/f_serialize/c/serialize.h +++ b/level_0/f_serialize/c/serialize.h @@ -30,54 +30,73 @@ extern "C" { #endif /** - * Serialized a string using the Simple serialize algorithm. + * Deserialize the entire serialize string into multiple separate strings using the Simple serialize algorithm. * * The simple Serialize algorithm is akin to the PATH environment variable, example: PATH="/bin:/sbin:/usr/bin". * - * To generate the above example, this would be called 3 times, with the following strings: - * 1) value = "/bin", then: PATH="/bin". - * 2) value = "/sbin", then: PATH="/bin:/sbin". - * 3) value = "/usr/sbin", then: PATH="/bin:/sbin:/usr/sbin". + * After processing the above example, there would be strings derived from the following positions: + * 1) start = 0, stop = 3. + * 2) start = 5, stop = 9. + * 3) start = 11, stop = 18. * - * @param value - * The string to append onto serialize. - * @param serialize - * The dynamic string that represents a serialize set of strings. + * @param source + * A serialized string to deserialize. + * @param destination + * An array of strings deserialize from the source string. + * The individual strings will be NULL terminated after destination.used on success. + * All deserialized values are appended to the destination. * * @return * F_none on success. - * F_memory_not (with error bit) on out of memory. + * F_complete_not_utf_eos if an incomplete UTF-8 character is found at the end of the source. + * F_data_not on success and source.used is 0. + * * F_parameter (with error bit) if a parameter is invalid. + * + * Errors (with error bit) from f_string_append(); + * Errors (with error bit) from f_string_dynamics_increase_by(); + * + * @see f_string_append() + * @see f_string_dynamics_increase_by() */ -#ifndef _di_f_serialize_simple_ - extern f_status_t f_serialize_simple(const f_string_static_t value, f_string_dynamic_t * const serialize); -#endif // _di_f_serialize_simple_ +#ifndef _di_f_serialize_from_simple_ + extern f_status_t f_serialize_from_simple(const f_string_static_t source, f_string_dynamics_t * const destination); +#endif // _di_f_serialize_from_simple_ /** - * De-serialize the entire serialize string into multiple separate strings using the Simple serialize algorithm. + * Unserialize and get a copy of a specific string using the Simple serialize algorithm. * * The simple Serialize algorithm is akin to the PATH environment variable, example: PATH="/bin:/sbin:/usr/bin". * - * After processing the above example, there would be the following positions: - * 1) start = 0, stop = 3. - * 2) start = 5, stop = 9. - * 3) start = 11, stop = 18. + * After processing the above example, there would be the following positions, for the given index: + * 1) with index = 0, start = 0, stop = 3. + * 2) with index = 1, start = 5, stop = 9. + * 3) with index = 2, start = 11, stop = 18. * - * @param serialize - * A serialize string to de-serialize. - * @param strings - * An array of strings de-serialize from serialize. + * @param source + * A serialized string to deserialize. + * @param index + * The selected position within the serialize string to get the deserialize positions of. + * @param destination + * The deserialized string from the specified index. + * This string is NULL terminated after destination.used on success. * * @return * F_none on success. - * F_complete_not_utf_eos if end of sting is reached before a complete UTF-8 character can be processed. - * F_array_too_large (with error bit) if a buffer would exceed maximum length. + * F_none_eos on success at end of string. + * F_data_not_eos if end of string reached before index was reached (dynamic->used is set to 0). + * F_data_not on success and source.used is 0. + * + * F_complete_not_utf_eos (with error bit) if end of string is reached before a complete UTF-8 character can be processed. * F_memory_not (with error bit) on out of memory. * F_parameter (with error bit) if a parameter is invalid. + * + * @see f_serialize_from_simple_select() + * @see f_string_append() */ -#ifndef _di_f_serialize_un_simple_ - extern f_status_t f_serialize_un_simple(const f_string_static_t serialize, f_string_dynamics_t * const strings); -#endif // _di_f_serialize_un_simple_ +#ifndef _di_f_serialize_from_simple_get_ + extern f_status_t f_serialize_from_simple_get(const f_string_static_t source, const f_array_length_t index, f_string_dynamic_t * const destination); +#endif // _di_f_serialize_from_simple_get_ /** * Identify string positions within a serialize string using the Simple serialize algorithm. @@ -89,78 +108,89 @@ extern "C" { * 2) start = 5, stop = 9. * 3) start = 11, stop = 18. * - * @param serialize - * A serialize string to de-serialize. - * @param locations - * The locations within the serialize string representing distinct separate strings. + * @param source + * A serialized string to deserialize. + * @param ranges + * The ranges within the serialize string representing distinct separate strings. + * All deserialized ranges are appended to the destination. * * @return * F_none on success. - * F_complete_not_utf_eos if end of sting is reached before a complete UTF-8 character can be processed. - * F_array_too_large (with error bit) if a buffer would exceed memory max length. - * F_memory_not (with error bit) on out of memory. + * F_complete_not_utf_eos if an incomplete UTF-8 character is found at the end of the source. + * F_data_not on success and source.used is 0. + * * F_parameter (with error bit) if a parameter is invalid. + * + * Errors (with error bit) from f_string_ranges_increase() + * + * @see f_string_ranges_increase() */ -#ifndef _di_f_serialize_un_simple_map_ - extern f_status_t f_serialize_un_simple_map(const f_string_static_t serialize, f_string_ranges_t * const locations); -#endif // _di_f_serialize_un_simple_map_ +#ifndef _di_f_serialize_from_simple_range_ + extern f_status_t f_serialize_from_simple_range(const f_string_static_t source, f_string_ranges_t * const ranges); +#endif // _di_f_serialize_from_simple_range_ /** - * Unserialize and find the address for a specific string using the Simple serialize algorithm. + * Deserialize and select the address for a specific string using the Simple serialize algorithm. * - * The simple Serialize algorithm is akin to the PATH environment variable, example: PATH="/bin:/sbin:/usr/bin". + * The simple serialize algorithm is akin to the PATH environment variable, example: PATH="/bin:/sbin:/usr/bin". * * After processing the above example, there would be the following positions, for the given index: * 1) with index = 0, start = 0, stop = 3. * 2) with index = 1, start = 5, stop = 9. * 3) with index = 2, start = 11, stop = 18. * - * @param serialize - * A serialize string to de-serialize. + * @param source + * A serialized string to deserialize. * @param index * An index position within the serialize string to get the deserialize positions of. - * @param location - * A location within the serialize string representing the string at the given index. + * @param range + * A range within the serialized string representing the string at the given index. * * @return * F_none on success. * F_none_eos on success at end of string. + * F_data_not on success and source.used is 0. * F_data_not_eos if end of string reached before index was reached. + * * F_complete_not_utf_eos (with error bit) if end of string is reached before a complete UTF-8 character can be processed. * F_parameter (with error bit) if a parameter is invalid. */ -#ifndef _di_f_serialize_un_simple_find_ - extern f_status_t f_serialize_un_simple_find(const f_string_static_t serialize, const f_array_length_t index, f_string_range_t * const location); -#endif // _di_f_serialize_un_simple_find_ +#ifndef _di_f_serialize_from_simple_select_ + extern f_status_t f_serialize_from_simple_select(const f_string_static_t source, const f_array_length_t index, f_string_range_t * const range); +#endif // _di_f_serialize_from_simple_select_ /** - * Unserialize and get a copy of a specific string using the Simple serialize algorithm. + * Serialized a string using the Simple serialize algorithm. * * The simple Serialize algorithm is akin to the PATH environment variable, example: PATH="/bin:/sbin:/usr/bin". * - * After processing the above example, there would be the following positions, for the given index: - * 1) with index = 0, start = 0, stop = 3. - * 2) with index = 1, start = 5, stop = 9. - * 3) with index = 2, start = 11, stop = 18. + * To generate the above example, this would be called 3 times, with the following strings: + * 1) value = "/bin", then: PATH="/bin". + * 2) value = "/sbin", then: PATH="/bin:/sbin". + * 3) value = "/usr/sbin", then: PATH="/bin:/sbin:/usr/sbin". * - * @param serialize - * A serialize string to de-serialize. - * @param index - * An index position within the serialize string to get the deserialize positions of. - * @param dynamic - * The unserialize string from the specified index. + * @param source + * The string to append onto serialize. + * @param destination + * The dynamic string that to store the serialized string. + * This string will be NULL terminated after destination.used on success. + * All serialized values are appended to the destination. * * @return * F_none on success. - * F_none_eos on success at end of string. - * F_data_not_eos if end of string reached before index was reached (dynamic->used is set to 0). - * F_complete_not_utf_eos (with error bit) if end of string is reached before a complete UTF-8 character can be processed. - * F_memory_not (with error bit) on out of memory. + * F_data_not on success and source.used is 0. + * * F_parameter (with error bit) if a parameter is invalid. + * + * Errors (with error bit) from f_string_dynamic_append(); + * Errors (with error bit) from f_string_dynamic_append_assure(); + * + * @see f_string_dynamic_append() + * @see f_string_dynamic_append_assure() */ -#ifndef _di_f_serialize_un_simple_get_ - extern f_status_t f_serialize_un_simple_get(const f_string_static_t serialize, const f_array_length_t index, f_string_dynamic_t * const dynamic); -#endif // _di_f_serialize_un_simple_get_ +#ifndef _di_f_serialize_to_simple_ + extern f_status_t f_serialize_to_simple(const f_string_static_t source, f_string_dynamic_t * const destination); +#endif // _di_f_serialize_to_simple_ #ifdef __cplusplus } // extern "C" diff --git a/level_0/f_serialize/c/serialize/common.c b/level_0/f_serialize/c/serialize/common.c index 99063dd..e80c31d 100644 --- a/level_0/f_serialize/c/serialize/common.c +++ b/level_0/f_serialize/c/serialize/common.c @@ -5,9 +5,9 @@ extern "C" { #endif #ifndef _di_f_serialize_splitter_s_ - const f_string_static_t f_serialize_simple_splitter_s = macro_f_string_static_t_initialize(F_serialize_simple_splitter_s, 0, F_serialize_simple_splitter_s_length); - const f_string_static_t f_serialize_delimited_splitter_s = macro_f_string_static_t_initialize(F_serialize_delimited_splitter_s, 0, F_serialize_delimited_splitter_s_length); const f_string_static_t f_serialize_delimited_delimiter_s = macro_f_string_static_t_initialize(F_serialize_delimited_delimiter_s, 0, F_serialize_delimited_delimiter_s_length); + const f_string_static_t f_serialize_delimited_splitter_s = macro_f_string_static_t_initialize(F_serialize_delimited_splitter_s, 0, F_serialize_delimited_splitter_s_length); + const f_string_static_t f_serialize_to_simple_splitter_s = macro_f_string_static_t_initialize(F_serialize_simple_splitter_s, 0, F_serialize_simple_splitter_s_length); #endif // _di_f_serialize_splitter_s_ #ifdef __cplusplus diff --git a/level_0/f_serialize/c/serialize/common.h b/level_0/f_serialize/c/serialize/common.h index 7686e37..5467848 100644 --- a/level_0/f_serialize/c/serialize/common.h +++ b/level_0/f_serialize/c/serialize/common.h @@ -17,17 +17,17 @@ extern "C" { #endif #ifndef _di_f_serialize_splitter_s_ - #define F_serialize_simple_splitter_s ":" - #define F_serialize_delimited_splitter_s "'" #define F_serialize_delimited_delimiter_s "\\" + #define F_serialize_delimited_splitter_s "'" + #define F_serialize_simple_splitter_s ":" - #define F_serialize_simple_splitter_s_length 1 - #define F_serialize_delimited_splitter_s_length 1 #define F_serialize_delimited_delimiter_s_length 1 + #define F_serialize_delimited_splitter_s_length 1 + #define F_serialize_simple_splitter_s_length 1 - extern const f_string_static_t f_serialize_simple_splitter_s; - extern const f_string_static_t f_serialize_delimited_splitter_s; extern const f_string_static_t f_serialize_delimited_delimiter_s; + extern const f_string_static_t f_serialize_delimited_splitter_s; + extern const f_string_static_t f_serialize_to_simple_splitter_s; #endif // _di_f_serialize_splitter_s_ #ifdef __cplusplus -- 1.8.3.1