Start implementing all of the macros as real functions for these.
Macros do what I wanted and save writing code, but the binary size is more of a concern.
Switching to explicit functions should also make debugging easier.
The macros may be removed eventually and all of the code utilizing the macros will be updated to use these.
There will be more changes like this going forward in some other projects like f_string and f_utf_string.
extern "C" {
#endif
+#if !defined(_di_f_type_cells_adjust_) || !defined(_di_f_type_cells_decimate_by_)
+ f_status_t private_f_type_cells_adjust(const f_array_length_t length, f_cells_t *cells) {
+
+ const f_status_t status = f_memory_adjust(cells->size, length, sizeof(f_cells_t), (void **) & cells->array);
+
+ if (F_status_is_error_not(status)) {
+ cells->size = length;
+
+ if (cells->used > cells->size) {
+ cells->used = length;
+ }
+ }
+
+ return status;
+ }
+#endif // !defined(_di_f_type_cells_adjust_) || !defined(_di_f_type_cells_decimate_by_)
+
+#if !defined(_di_f_type_cells_append_) || !defined(_di_f_type_cellss_append_)
+ extern f_status_t private_f_type_cells_append(const f_cells_t source, f_cells_t *destination) {
+ f_status_t status = F_none;
+
+ if (destination->used + source.used > destination->size) {
+ status = private_f_type_cells_adjust(destination->used + source.used, destination);
+ if (F_status_is_error(status)) return status;
+ }
+
+ for (f_array_length_t i = 0; i < source.used; ++i, ++destination->used) {
+ destination->array[destination->used] = source.array[i];
+ } // for
+
+ return F_none;
+ }
+#endif // !defined(_di_f_type_cells_append_) || !defined(_di_f_type_cellss_append_)
+
+#if !defined(_di_f_type_cells_resize_) || !defined(_di_f_type_cells_append_) || !defined(_di_f_type_cells_decimate_by_) || !defined(_di_f_type_cellss_append_)
+ f_status_t private_f_type_cells_resize(const f_array_length_t length, f_cells_t *cells) {
+
+ const f_status_t status = f_memory_resize(cells->size, length, sizeof(f_cells_t), (void **) & cells->array);
+
+ if (F_status_is_error_not(status)) {
+ cells->size = length;
+
+ if (cells->used > cells->size) {
+ cells->used = length;
+ }
+ }
+
+ return status;
+ }
+#endif // !defined(_di_f_type_cells_resize_) || !defined(_di_f_type_cells_append_) || !defined(_di_f_type_cells_decimate_by_) || !defined(_di_f_type_cellss_append_)
+
#if !defined(_di_f_type_cellss_adjust_) || !defined(_di_f_type_cellss_decimate_by_)
f_status_t private_f_type_cellss_adjust(const f_array_length_t length, f_cellss_t *cellss) {
f_status_t status = F_none;
}
#endif // !defined(_di_f_type_cellss_adjust_) || !defined(_di_f_type_cellss_decimate_by_)
-#if !defined(_di_f_type_cellss_decrease_by_) || !defined(_di_f_type_cellss_increase_) || !defined(_di_f_type_cellss_increase_by_)
+#if !defined(_di_f_type_cellss_decrease_by_) || !defined(_di_f_type_cellss_increase_) || !defined(_di_f_type_cellss_increase_by_) || !defined(_di_f_type_cellss_resize_)
f_status_t private_f_type_cellss_resize(const f_array_length_t length, f_cellss_t *cellss) {
f_status_t status = F_none;
return status;
}
-#endif // !defined(_di_f_type_cellss_decrease_by_) || !defined(_di_f_type_cellss_increase_) || !defined(_di_f_type_cellss_increase_by_)
+#endif // !defined(_di_f_type_cellss_decrease_by_) || !defined(_di_f_type_cellss_increase_) || !defined(_di_f_type_cellss_increase_by_) || !defined(_di_f_type_cellss_resize_)
+
+#if !defined(_di_f_type_array_lengths_adjust_) || !defined(_di_f_type_array_lengths_decimate_by_)
+ f_status_t private_f_type_array_lengths_adjust(const f_array_length_t length, f_array_lengths_t *array_lengths) {
+
+ const f_status_t status = f_memory_adjust(array_lengths->size, length, sizeof(f_array_lengths_t), (void **) & array_lengths->array);
+
+ if (F_status_is_error_not(status)) {
+ array_lengths->size = length;
+
+ if (array_lengths->used > array_lengths->size) {
+ array_lengths->used = length;
+ }
+ }
+
+ return status;
+ }
+#endif // !defined(_di_f_type_array_lengths_adjust_) || !defined(_di_f_type_array_lengths_decimate_by_)
+
+#if !defined(_di_f_type_array_lengths_append_) || !defined(_di_f_type_array_lengthss_append_)
+ extern f_status_t private_f_type_array_lengths_append(const f_array_lengths_t source, f_array_lengths_t *destination) {
+ f_status_t status = F_none;
+
+ if (destination->used + source.used > destination->size) {
+ status = private_f_type_array_lengths_adjust(destination->used + source.used, destination);
+ if (F_status_is_error(status)) return status;
+ }
+
+ for (f_array_length_t i = 0; i < source.used; ++i, ++destination->used) {
+ destination->array[destination->used] = source.array[i];
+ } // for
+
+ return F_none;
+ }
+#endif // !defined(_di_f_type_array_lengths_append_) || !defined(_di_f_type_array_lengthss_append_)
+
+#if !defined(_di_f_type_array_lengths_resize_) || !defined(_di_f_type_array_lengths_append_) || !defined(_di_f_type_array_lengths_decimate_by_) || !defined(_di_f_type_array_lengthss_append_)
+ f_status_t private_f_type_array_lengths_resize(const f_array_length_t length, f_array_lengths_t *lengths) {
+
+ const f_status_t status = f_memory_resize(lengths->size, length, sizeof(f_array_lengths_t), (void **) & lengths->array);
+
+ if (F_status_is_error_not(status)) {
+ lengths->size = length;
+
+ if (lengths->used > lengths->size) {
+ lengths->used = length;
+ }
+ }
+
+ return status;
+ }
+#endif // !defined(_di_f_type_array_lengths_resize_) || !defined(_di_f_type_array_lengths_append_) || !defined(_di_f_type_array_lengths_decimate_by_) || !defined(_di_f_type_array_lengthss_append_)
#if !defined(_di_f_type_array_lengthss_adjust_) || !defined(_di_f_type_array_lengthss_decimate_by_)
- f_status_t private_f_type_array_lengthss_adjust(const f_array_length_t length, f_array_lengthss_t *array_lengthss) {
+ f_status_t private_f_type_array_lengthss_adjust(const f_array_length_t length, f_array_lengthss_t *lengthss) {
f_status_t status = F_none;
- for (f_array_length_t i = length; i < array_lengthss->size; ++i) {
+ for (f_array_length_t i = length; i < lengthss->size; ++i) {
- status = f_memory_destroy(array_lengthss->array[i].size, sizeof(f_array_lengths_t), (void **) & array_lengthss->array[i].array);
+ status = f_memory_destroy(lengthss->array[i].size, sizeof(f_array_lengths_t), (void **) & lengthss->array[i].array);
if (F_status_is_error(status)) return status;
- array_lengthss->array[i].size = 0;
- array_lengthss->array[i].used = 0;
+ lengthss->array[i].size = 0;
+ lengthss->array[i].used = 0;
} // for
- status = f_memory_adjust(array_lengthss->size, length, sizeof(f_array_lengths_t), (void **) & array_lengthss->array);
+ status = f_memory_adjust(lengthss->size, length, sizeof(f_array_lengths_t), (void **) & lengthss->array);
if (F_status_is_error_not(status)) {
- array_lengthss->size = length;
+ lengthss->size = length;
- if (array_lengthss->used > array_lengthss->size) {
- array_lengthss->used = length;
+ if (lengthss->used > lengthss->size) {
+ lengthss->used = length;
}
}
}
#endif // !defined(_di_f_type_array_lengthss_adjust_) || !defined(_di_f_type_array_lengthss_decimate_by_)
-#if !defined(_di_f_type_array_lengthss_decrease_by_) || !defined(_di_f_type_array_lengthss_increase_) || !defined(_di_f_type_array_lengthss_increase_by_)
- f_status_t private_f_type_array_lengthss_resize(const f_array_length_t length, f_array_lengthss_t *array_lengthss) {
+#if !defined(_di_f_type_array_lengthss_decrease_by_) || !defined(_di_f_type_array_lengthss_increase_) || !defined(_di_f_type_array_lengthss_increase_by_) || !defined(_di_f_type_array_lengthss_resize_)
+ f_status_t private_f_type_array_lengthss_resize(const f_array_length_t length, f_array_lengthss_t *lengthss) {
f_status_t status = F_none;
- for (f_array_length_t i = length; i < array_lengthss->size; ++i) {
+ for (f_array_length_t i = length; i < lengthss->size; ++i) {
- status = f_memory_delete(array_lengthss->array[i].size, sizeof(f_array_lengths_t), (void **) & array_lengthss->array[i].array);
+ status = f_memory_delete(lengthss->array[i].size, sizeof(f_array_lengths_t), (void **) & lengthss->array[i].array);
if (F_status_is_error(status)) return status;
- array_lengthss->array[i].size = 0;
- array_lengthss->array[i].used = 0;
+ lengthss->array[i].size = 0;
+ lengthss->array[i].used = 0;
} // for
- status = f_memory_resize(array_lengthss->size, length, sizeof(f_array_lengths_t), (void **) & array_lengthss->array);
+ status = f_memory_resize(lengthss->size, length, sizeof(f_array_lengths_t), (void **) & lengthss->array);
+
+ if (F_status_is_error_not(status)) {
+ lengthss->size = length;
+
+ if (lengthss->used > lengthss->size) {
+ lengthss->used = length;
+ }
+ }
+
+ return status;
+ }
+#endif // !defined(_di_f_type_array_lengthss_decrease_by_) || !defined(_di_f_type_array_lengthss_increase_) || !defined(_di_f_type_array_lengthss_increase_by_) || !defined(_di_f_type_array_lengthss_resize_)
+
+#if !defined(_di_f_type_int8s_adjust_) || !defined(_di_f_type_int8s_decimate_by_)
+ f_status_t private_f_type_int8s_adjust(const f_array_length_t length, f_int8s_t *int8s) {
+
+ const f_status_t status = f_memory_adjust(int8s->size, length, sizeof(f_int8s_t), (void **) & int8s->array);
+
+ if (F_status_is_error_not(status)) {
+ int8s->size = length;
+
+ if (int8s->used > int8s->size) {
+ int8s->used = length;
+ }
+ }
+
+ return status;
+ }
+#endif // !defined(_di_f_type_int8s_adjust_) || !defined(_di_f_type_int8s_decimate_by_)
+
+#if !defined(_di_f_type_int8s_append_) || !defined(_di_f_type_int8ss_append_)
+ extern f_status_t private_f_type_int8s_append(const f_int8s_t source, f_int8s_t *destination) {
+ f_status_t status = F_none;
+
+ if (destination->used + source.used > destination->size) {
+ status = private_f_type_int8s_adjust(destination->used + source.used, destination);
+ if (F_status_is_error(status)) return status;
+ }
+
+ for (f_array_length_t i = 0; i < source.used; ++i, ++destination->used) {
+ destination->array[destination->used] = source.array[i];
+ } // for
+
+ return F_none;
+ }
+#endif // !defined(_di_f_type_int8s_append_) || !defined(_di_f_type_int8ss_append_)
+
+#if !defined(_di_f_type_int8s_resize_) || !defined(_di_f_type_int8s_append_) || !defined(_di_f_type_int8s_decimate_by_) || !defined(_di_f_type_int8ss_append_)
+ f_status_t private_f_type_int8s_resize(const f_array_length_t length, f_int8s_t *int8s) {
+
+ const f_status_t status = f_memory_resize(int8s->size, length, sizeof(f_int8s_t), (void **) & int8s->array);
if (F_status_is_error_not(status)) {
- array_lengthss->size = length;
+ int8s->size = length;
- if (array_lengthss->used > array_lengthss->size) {
- array_lengthss->used = length;
+ if (int8s->used > int8s->size) {
+ int8s->used = length;
}
}
return status;
}
-#endif // !defined(_di_f_type_array_lengthss_decrease_by_) || !defined(_di_f_type_array_lengthss_increase_) || !defined(_di_f_type_array_lengthss_increase_by_)
+#endif // !defined(_di_f_type_int8s_resize_) || !defined(_di_f_type_int8s_append_) || !defined(_di_f_type_int8s_decimate_by_) || !defined(_di_f_type_int8ss_append_)
#if !defined(_di_f_type_int8ss_adjust_) || !defined(_di_f_type_int8ss_decimate_by_)
f_status_t private_f_type_int8ss_adjust(const f_array_length_t length, f_int8ss_t *int8ss) {
}
#endif // !defined(_di_f_type_int8ss_adjust_) || !defined(_di_f_type_int8ss_decimate_by_)
-#if !defined(_di_f_type_int8ss_decrease_by_) || !defined(_di_f_type_int8ss_increase_) || !defined(_di_f_type_int8ss_increase_by_)
+#if !defined(_di_f_type_int8ss_decrease_by_) || !defined(_di_f_type_int8ss_increase_) || !defined(_di_f_type_int8ss_increase_by_) || !defined(_di_f_type_int8ss_resize_)
f_status_t private_f_type_int8ss_resize(const f_array_length_t length, f_int8ss_t *int8ss) {
f_status_t status = F_none;
return status;
}
-#endif // !defined(_di_f_type_int8ss_decrease_by_) || !defined(_di_f_type_int8ss_increase_) || !defined(_di_f_type_int8ss_increase_by_)
+#endif // !defined(_di_f_type_int8ss_decrease_by_) || !defined(_di_f_type_int8ss_increase_) || !defined(_di_f_type_int8ss_increase_by_) || !defined(_di_f_type_int8ss_resize_)
+
+#if !defined(_di_f_type_uint8s_adjust_) || !defined(_di_f_type_uint8s_decimate_by_)
+ f_status_t private_f_type_uint8s_adjust(const f_array_length_t length, f_uint8s_t *uint8s) {
+
+ const f_status_t status = f_memory_adjust(uint8s->size, length, sizeof(f_uint8s_t), (void **) & uint8s->array);
+
+ if (F_status_is_error_not(status)) {
+ uint8s->size = length;
+
+ if (uint8s->used > uint8s->size) {
+ uint8s->used = length;
+ }
+ }
+
+ return status;
+ }
+#endif // !defined(_di_f_type_uint8s_adjust_) || !defined(_di_f_type_uint8s_decimate_by_)
+
+#if !defined(_di_f_type_uint8s_append_) || !defined(_di_f_type_uint8ss_append_)
+ extern f_status_t private_f_type_uint8s_append(const f_uint8s_t source, f_uint8s_t *destination) {
+ f_status_t status = F_none;
+
+ if (destination->used + source.used > destination->size) {
+ status = private_f_type_uint8s_adjust(destination->used + source.used, destination);
+ if (F_status_is_error(status)) return status;
+ }
+
+ for (f_array_length_t i = 0; i < source.used; ++i, ++destination->used) {
+ destination->array[destination->used] = source.array[i];
+ } // for
+
+ return F_none;
+ }
+#endif // !defined(_di_f_type_uint8s_append_) || !defined(_di_f_type_uint8ss_append_)
+
+#if !defined(_di_f_type_uint8s_resize_) || !defined(_di_f_type_uint8s_append_) || !defined(_di_f_type_uint8s_decimate_by_) || !defined(_di_f_type_uint8ss_append_)
+ f_status_t private_f_type_uint8s_resize(const f_array_length_t length, f_uint8s_t *uint8s) {
+
+ const f_status_t status = f_memory_resize(uint8s->size, length, sizeof(f_uint8s_t), (void **) & uint8s->array);
+
+ if (F_status_is_error_not(status)) {
+ uint8s->size = length;
+
+ if (uint8s->used > uint8s->size) {
+ uint8s->used = length;
+ }
+ }
+
+ return status;
+ }
+#endif // !defined(_di_f_type_uint8s_resize_) || !defined(_di_f_type_uint8s_append_) || !defined(_di_f_type_uint8s_decimate_by_) || !defined(_di_f_type_uint8ss_append_)
#if !defined(_di_f_type_uint8ss_adjust_) || !defined(_di_f_type_uint8ss_decimate_by_)
f_status_t private_f_type_uint8ss_adjust(const f_array_length_t length, f_uint8ss_t *uint8ss) {
}
#endif // !defined(_di_f_type_uint8ss_adjust_) || !defined(_di_f_type_uint8ss_decimate_by_)
-#if !defined(_di_f_type_uint8ss_decrease_by_) || !defined(_di_f_type_uint8ss_increase_) || !defined(_di_f_type_uint8ss_increase_by_)
+#if !defined(_di_f_type_uint8ss_decrease_by_) || !defined(_di_f_type_uint8ss_increase_) || !defined(_di_f_type_uint8ss_increase_by_) || !defined(_di_f_type_uint8ss_resize_)
f_status_t private_f_type_uint8ss_resize(const f_array_length_t length, f_uint8ss_t *uint8ss) {
f_status_t status = F_none;
return status;
}
-#endif // !defined(_di_f_type_uint8ss_decrease_by_) || !defined(_di_f_type_uint8ss_increase_) || !defined(_di_f_type_uint8ss_increase_by_)
+#endif // !defined(_di_f_type_uint8ss_decrease_by_) || !defined(_di_f_type_uint8ss_increase_) || !defined(_di_f_type_uint8ss_increase_by_) || !defined(_di_f_type_uint8ss_resize_)
+
+#if !defined(_di_f_type_int16s_adjust_) || !defined(_di_f_type_int16s_decimate_by_)
+ f_status_t private_f_type_int16s_adjust(const f_array_length_t length, f_int16s_t *int16s) {
+
+ const f_status_t status = f_memory_adjust(int16s->size, length, sizeof(f_int16s_t), (void **) & int16s->array);
+
+ if (F_status_is_error_not(status)) {
+ int16s->size = length;
+
+ if (int16s->used > int16s->size) {
+ int16s->used = length;
+ }
+ }
+
+ return status;
+ }
+#endif // !defined(_di_f_type_int16s_adjust_) || !defined(_di_f_type_int16s_decimate_by_)
+
+#if !defined(_di_f_type_int16s_append_) || !defined(_di_f_type_int16ss_append_)
+ extern f_status_t private_f_type_int16s_append(const f_int16s_t source, f_int16s_t *destination) {
+ f_status_t status = F_none;
+
+ if (destination->used + source.used > destination->size) {
+ status = private_f_type_int16s_adjust(destination->used + source.used, destination);
+ if (F_status_is_error(status)) return status;
+ }
+
+ for (f_array_length_t i = 0; i < source.used; ++i, ++destination->used) {
+ destination->array[destination->used] = source.array[i];
+ } // for
+
+ return F_none;
+ }
+#endif // !defined(_di_f_type_int16s_append_) || !defined(_di_f_type_int16ss_append_)
+
+#if !defined(_di_f_type_int16s_resize_) || !defined(_di_f_type_int16s_append_) || !defined(_di_f_type_int16s_decimate_by_) || !defined(_di_f_type_int16ss_append_)
+ f_status_t private_f_type_int16s_resize(const f_array_length_t length, f_int16s_t *int16s) {
+
+ const f_status_t status = f_memory_resize(int16s->size, length, sizeof(f_int16s_t), (void **) & int16s->array);
+
+ if (F_status_is_error_not(status)) {
+ int16s->size = length;
+
+ if (int16s->used > int16s->size) {
+ int16s->used = length;
+ }
+ }
+
+ return status;
+ }
+#endif // !defined(_di_f_type_int16s_resize_) || !defined(_di_f_type_int16s_append_) || !defined(_di_f_type_int16s_decimate_by_) || !defined(_di_f_type_int16ss_append_)
#if !defined(_di_f_type_int16ss_adjust_) || !defined(_di_f_type_int16ss_decimate_by_)
f_status_t private_f_type_int16ss_adjust(const f_array_length_t length, f_int16ss_t *int16ss) {
}
#endif // !defined(_di_f_type_int16ss_adjust_) || !defined(_di_f_type_int16ss_decimate_by_)
-#if !defined(_di_f_type_int16ss_decrease_by_) || !defined(_di_f_type_int16ss_increase_) || !defined(_di_f_type_int16ss_increase_by_)
+#if !defined(_di_f_type_int16ss_decrease_by_) || !defined(_di_f_type_int16ss_increase_) || !defined(_di_f_type_int16ss_increase_by_) || !defined(_di_f_type_int16ss_resize_)
f_status_t private_f_type_int16ss_resize(const f_array_length_t length, f_int16ss_t *int16ss) {
f_status_t status = F_none;
return status;
}
-#endif // !defined(_di_f_type_int16ss_decrease_by_) || !defined(_di_f_type_int16ss_increase_) || !defined(_di_f_type_int16ss_increase_by_)
+#endif // !defined(_di_f_type_int16ss_decrease_by_) || !defined(_di_f_type_int16ss_increase_) || !defined(_di_f_type_int16ss_increase_by_) || !defined(_di_f_type_int16ss_resize_)
+
+#if !defined(_di_f_type_uint16s_adjust_) || !defined(_di_f_type_uint16s_decimate_by_)
+ f_status_t private_f_type_uint16s_adjust(const f_array_length_t length, f_uint16s_t *uint16s) {
+
+ const f_status_t status = f_memory_adjust(uint16s->size, length, sizeof(f_uint16s_t), (void **) & uint16s->array);
+
+ if (F_status_is_error_not(status)) {
+ uint16s->size = length;
+
+ if (uint16s->used > uint16s->size) {
+ uint16s->used = length;
+ }
+ }
+
+ return status;
+ }
+#endif // !defined(_di_f_type_uint16s_adjust_) || !defined(_di_f_type_uint16s_decimate_by_)
+
+#if !defined(_di_f_type_uint16s_append_) || !defined(_di_f_type_uint16ss_append_)
+ extern f_status_t private_f_type_uint16s_append(const f_uint16s_t source, f_uint16s_t *destination) {
+ f_status_t status = F_none;
+
+ if (destination->used + source.used > destination->size) {
+ status = private_f_type_uint16s_adjust(destination->used + source.used, destination);
+ if (F_status_is_error(status)) return status;
+ }
+
+ for (f_array_length_t i = 0; i < source.used; ++i, ++destination->used) {
+ destination->array[destination->used] = source.array[i];
+ } // for
+
+ return F_none;
+ }
+#endif // !defined(_di_f_type_uint16s_append_) || !defined(_di_f_type_uint16ss_append_)
+
+#if !defined(_di_f_type_uint16s_resize_) || !defined(_di_f_type_uint16s_append_) || !defined(_di_f_type_uint16s_decimate_by_) || !defined(_di_f_type_uint16ss_append_)
+ f_status_t private_f_type_uint16s_resize(const f_array_length_t length, f_uint16s_t *uint16s) {
+
+ const f_status_t status = f_memory_resize(uint16s->size, length, sizeof(f_uint16s_t), (void **) & uint16s->array);
+
+ if (F_status_is_error_not(status)) {
+ uint16s->size = length;
+
+ if (uint16s->used > uint16s->size) {
+ uint16s->used = length;
+ }
+ }
+
+ return status;
+ }
+#endif // !defined(_di_f_type_uint16s_resize_) || !defined(_di_f_type_uint16s_append_) || !defined(_di_f_type_uint16s_decimate_by_) || !defined(_di_f_type_uint16ss_append_)
#if !defined(_di_f_type_uint16ss_adjust_) || !defined(_di_f_type_uint16ss_decimate_by_)
f_status_t private_f_type_uint16ss_adjust(const f_array_length_t length, f_uint16ss_t *uint16ss) {
}
#endif // !defined(_di_f_type_uint16ss_adjust_) || !defined(_di_f_type_uint16ss_decimate_by_)
-#if !defined(_di_f_type_uint16ss_decrease_by_) || !defined(_di_f_type_uint16ss_increase_) || !defined(_di_f_type_uint16ss_increase_by_)
+#if !defined(_di_f_type_uint16ss_decrease_by_) || !defined(_di_f_type_uint16ss_increase_) || !defined(_di_f_type_uint16ss_increase_by_) || !defined(_di_f_type_uint16ss_resize_)
f_status_t private_f_type_uint16ss_resize(const f_array_length_t length, f_uint16ss_t *uint16ss) {
f_status_t status = F_none;
for (f_array_length_t i = length; i < uint16ss->size; ++i) {
- status = f_memory_delete(uint16ss->array[i].size, sizeof(f_uint8s_t), (void **) & uint16ss->array[i].array);
+ status = f_memory_delete(uint16ss->array[i].size, sizeof(f_uint16s_t), (void **) & uint16ss->array[i].array);
if (F_status_is_error(status)) return status;
uint16ss->array[i].size = 0;
uint16ss->array[i].used = 0;
} // for
- status = f_memory_resize(uint16ss->size, length, sizeof(f_uint8s_t), (void **) & uint16ss->array);
+ status = f_memory_resize(uint16ss->size, length, sizeof(f_uint16s_t), (void **) & uint16ss->array);
if (F_status_is_error_not(status)) {
uint16ss->size = length;
return status;
}
-#endif // !defined(_di_f_type_uint16ss_decrease_by_) || !defined(_di_f_type_uint16ss_increase_) || !defined(_di_f_type_uint16ss_increase_by_)
+#endif // !defined(_di_f_type_uint16ss_decrease_by_) || !defined(_di_f_type_uint16ss_increase_) || !defined(_di_f_type_uint16ss_increase_by_) || !defined(_di_f_type_uint16ss_resize_)
+
+#if !defined(_di_f_type_int32s_adjust_) || !defined(_di_f_type_int32s_decimate_by_)
+ f_status_t private_f_type_int32s_adjust(const f_array_length_t length, f_int32s_t *int32s) {
+
+ const f_status_t status = f_memory_adjust(int32s->size, length, sizeof(f_int32s_t), (void **) & int32s->array);
+
+ if (F_status_is_error_not(status)) {
+ int32s->size = length;
+
+ if (int32s->used > int32s->size) {
+ int32s->used = length;
+ }
+ }
+
+ return status;
+ }
+#endif // !defined(_di_f_type_int32s_adjust_) || !defined(_di_f_type_int32s_decimate_by_)
+
+#if !defined(_di_f_type_int32s_append_) || !defined(_di_f_type_int32ss_append_)
+ extern f_status_t private_f_type_int32s_append(const f_int32s_t source, f_int32s_t *destination) {
+ f_status_t status = F_none;
+
+ if (destination->used + source.used > destination->size) {
+ status = private_f_type_int32s_adjust(destination->used + source.used, destination);
+ if (F_status_is_error(status)) return status;
+ }
+
+ for (f_array_length_t i = 0; i < source.used; ++i, ++destination->used) {
+ destination->array[destination->used] = source.array[i];
+ } // for
+
+ return F_none;
+ }
+#endif // !defined(_di_f_type_int32s_append_) || !defined(_di_f_type_int32ss_append_)
+
+#if !defined(_di_f_type_int32s_resize_) || !defined(_di_f_type_int32s_append_) || !defined(_di_f_type_int32s_decimate_by_) || !defined(_di_f_type_int32ss_append_)
+ f_status_t private_f_type_int32s_resize(const f_array_length_t length, f_int32s_t *int32s) {
+
+ const f_status_t status = f_memory_resize(int32s->size, length, sizeof(f_int32s_t), (void **) & int32s->array);
+
+ if (F_status_is_error_not(status)) {
+ int32s->size = length;
+
+ if (int32s->used > int32s->size) {
+ int32s->used = length;
+ }
+ }
+
+ return status;
+ }
+#endif // !defined(_di_f_type_int32s_resize_) || !defined(_di_f_type_int32s_append_) || !defined(_di_f_type_int32s_decimate_by_) || !defined(_di_f_type_int32ss_append_)
#if !defined(_di_f_type_int32ss_adjust_) || !defined(_di_f_type_int32ss_decimate_by_)
f_status_t private_f_type_int32ss_adjust(const f_array_length_t length, f_int32ss_t *int32ss) {
}
#endif // !defined(_di_f_type_int32ss_adjust_) || !defined(_di_f_type_int32ss_decimate_by_)
-#if !defined(_di_f_type_int32ss_decrease_by_) || !defined(_di_f_type_int32ss_increase_) || !defined(_di_f_type_int32ss_increase_by_)
+#if !defined(_di_f_type_int32ss_decrease_by_) || !defined(_di_f_type_int32ss_increase_) || !defined(_di_f_type_int32ss_increase_by_) || !defined(_di_f_type_int32ss_resize_)
f_status_t private_f_type_int32ss_resize(const f_array_length_t length, f_int32ss_t *int32ss) {
f_status_t status = F_none;
return status;
}
-#endif // !defined(_di_f_type_int32ss_decrease_by_) || !defined(_di_f_type_int32ss_increase_) || !defined(_di_f_type_int32ss_increase_by_)
+#endif // !defined(_di_f_type_int32ss_decrease_by_) || !defined(_di_f_type_int32ss_increase_) || !defined(_di_f_type_int32ss_increase_by_) || !defined(_di_f_type_int32ss_resize_)
+
+#if !defined(_di_f_type_uint32s_adjust_) || !defined(_di_f_type_uint32s_decimate_by_)
+ f_status_t private_f_type_uint32s_adjust(const f_array_length_t length, f_uint32s_t *uint32s) {
+
+ const f_status_t status = f_memory_adjust(uint32s->size, length, sizeof(f_uint32s_t), (void **) & uint32s->array);
+
+ if (F_status_is_error_not(status)) {
+ uint32s->size = length;
+
+ if (uint32s->used > uint32s->size) {
+ uint32s->used = length;
+ }
+ }
+
+ return status;
+ }
+#endif // !defined(_di_f_type_uint32s_adjust_) || !defined(_di_f_type_uint32s_decimate_by_)
+
+#if !defined(_di_f_type_uint32s_append_) || !defined(_di_f_type_uint32ss_append_)
+ extern f_status_t private_f_type_uint32s_append(const f_uint32s_t source, f_uint32s_t *destination) {
+ f_status_t status = F_none;
+
+ if (destination->used + source.used > destination->size) {
+ status = private_f_type_uint32s_adjust(destination->used + source.used, destination);
+ if (F_status_is_error(status)) return status;
+ }
+
+ for (f_array_length_t i = 0; i < source.used; ++i, ++destination->used) {
+ destination->array[destination->used] = source.array[i];
+ } // for
+
+ return F_none;
+ }
+#endif // !defined(_di_f_type_uint32s_append_) || !defined(_di_f_type_uint32ss_append_)
+
+#if !defined(_di_f_type_uint32s_resize_) || !defined(_di_f_type_uint32s_append_) || !defined(_di_f_type_uint32s_decimate_by_) || !defined(_di_f_type_uint32ss_append_)
+ f_status_t private_f_type_uint32s_resize(const f_array_length_t length, f_uint32s_t *uint32s) {
+
+ const f_status_t status = f_memory_resize(uint32s->size, length, sizeof(f_uint32s_t), (void **) & uint32s->array);
+
+ if (F_status_is_error_not(status)) {
+ uint32s->size = length;
+
+ if (uint32s->used > uint32s->size) {
+ uint32s->used = length;
+ }
+ }
+
+ return status;
+ }
+#endif // !defined(_di_f_type_uint32s_resize_) || !defined(_di_f_type_uint32s_append_) || !defined(_di_f_type_uint32s_decimate_by_) || !defined(_di_f_type_uint32ss_append_)
#if !defined(_di_f_type_uint32ss_adjust_) || !defined(_di_f_type_uint32ss_decimate_by_)
f_status_t private_f_type_uint32ss_adjust(const f_array_length_t length, f_uint32ss_t *uint32ss) {
}
#endif // !defined(_di_f_type_uint32ss_adjust_) || !defined(_di_f_type_uint32ss_decimate_by_)
-#if !defined(_di_f_type_uint32ss_decrease_by_) || !defined(_di_f_type_uint32ss_increase_) || !defined(_di_f_type_uint32ss_increase_by_)
+#if !defined(_di_f_type_uint32ss_decrease_by_) || !defined(_di_f_type_uint32ss_increase_) || !defined(_di_f_type_uint32ss_increase_by_) || !defined(_di_f_type_uint32ss_resize_)
f_status_t private_f_type_uint32ss_resize(const f_array_length_t length, f_uint32ss_t *uint32ss) {
f_status_t status = F_none;
return status;
}
-#endif // !defined(_di_f_type_uint32ss_decrease_by_) || !defined(_di_f_type_uint32ss_increase_) || !defined(_di_f_type_uint32ss_increase_by_)
+#endif // !defined(_di_f_type_uint32ss_decrease_by_) || !defined(_di_f_type_uint32ss_increase_) || !defined(_di_f_type_uint32ss_increase_by_) || !defined(_di_f_type_uint32ss_resize_)
+
+#if !defined(_di_f_type_int64s_adjust_) || !defined(_di_f_type_int64s_decimate_by_)
+ f_status_t private_f_type_int64s_adjust(const f_array_length_t length, f_int64s_t *int64s) {
+
+ const f_status_t status = f_memory_adjust(int64s->size, length, sizeof(f_int64s_t), (void **) & int64s->array);
+
+ if (F_status_is_error_not(status)) {
+ int64s->size = length;
+
+ if (int64s->used > int64s->size) {
+ int64s->used = length;
+ }
+ }
+
+ return status;
+ }
+#endif // !defined(_di_f_type_int64s_adjust_) || !defined(_di_f_type_int64s_decimate_by_)
+
+#if !defined(_di_f_type_int64s_append_) || !defined(_di_f_type_int64ss_append_)
+ extern f_status_t private_f_type_int64s_append(const f_int64s_t source, f_int64s_t *destination) {
+ f_status_t status = F_none;
+
+ if (destination->used + source.used > destination->size) {
+ status = private_f_type_int64s_adjust(destination->used + source.used, destination);
+ if (F_status_is_error(status)) return status;
+ }
+
+ for (f_array_length_t i = 0; i < source.used; ++i, ++destination->used) {
+ destination->array[destination->used] = source.array[i];
+ } // for
+
+ return F_none;
+ }
+#endif // !defined(_di_f_type_int64s_append_) || !defined(_di_f_type_int64ss_append_)
+
+#if !defined(_di_f_type_int64s_resize_) || !defined(_di_f_type_int64s_append_) || !defined(_di_f_type_int64s_decimate_by_) || !defined(_di_f_type_int64ss_append_)
+ f_status_t private_f_type_int64s_resize(const f_array_length_t length, f_int64s_t *int64s) {
+
+ const f_status_t status = f_memory_resize(int64s->size, length, sizeof(f_int64s_t), (void **) & int64s->array);
+
+ if (F_status_is_error_not(status)) {
+ int64s->size = length;
+
+ if (int64s->used > int64s->size) {
+ int64s->used = length;
+ }
+ }
+
+ return status;
+ }
+#endif // !defined(_di_f_type_int64s_resize_) || !defined(_di_f_type_int64s_append_) || !defined(_di_f_type_int64s_decimate_by_) || !defined(_di_f_type_int64ss_append_)
#if !defined(_di_f_type_int64ss_adjust_) || !defined(_di_f_type_int64ss_decimate_by_)
f_status_t private_f_type_int64ss_adjust(const f_array_length_t length, f_int64ss_t *int64ss) {
}
#endif // !defined(_di_f_type_int64ss_adjust_) || !defined(_di_f_type_int64ss_decimate_by_)
-#if !defined(_di_f_type_int64ss_decrease_by_) || !defined(_di_f_type_int64ss_increase_) || !defined(_di_f_type_int64ss_increase_by_)
+#if !defined(_di_f_type_int64ss_decrease_by_) || !defined(_di_f_type_int64ss_increase_) || !defined(_di_f_type_int64ss_increase_by_) || !defined(_di_f_type_int64ss_resize_)
f_status_t private_f_type_int64ss_resize(const f_array_length_t length, f_int64ss_t *int64ss) {
f_status_t status = F_none;
return status;
}
-#endif // !defined(_di_f_type_int64ss_decrease_by_) || !defined(_di_f_type_int64ss_increase_) || !defined(_di_f_type_int64ss_increase_by_)
+#endif // !defined(_di_f_type_int64ss_decrease_by_) || !defined(_di_f_type_int64ss_increase_) || !defined(_di_f_type_int64ss_increase_by_) || !defined(_di_f_type_int64ss_resize_)
+
+#if !defined(_di_f_type_uint64s_adjust_) || !defined(_di_f_type_uint64s_decimate_by_)
+ f_status_t private_f_type_uint64s_adjust(const f_array_length_t length, f_uint64s_t *uint64s) {
+
+ const f_status_t status = f_memory_adjust(uint64s->size, length, sizeof(f_uint64s_t), (void **) & uint64s->array);
+
+ if (F_status_is_error_not(status)) {
+ uint64s->size = length;
+
+ if (uint64s->used > uint64s->size) {
+ uint64s->used = length;
+ }
+ }
+
+ return status;
+ }
+#endif // !defined(_di_f_type_uint64s_adjust_) || !defined(_di_f_type_uint64s_decimate_by_)
+
+#if !defined(_di_f_type_uint64s_append_) || !defined(_di_f_type_uint64ss_append_)
+ extern f_status_t private_f_type_uint64s_append(const f_uint64s_t source, f_uint64s_t *destination) {
+ f_status_t status = F_none;
+
+ if (destination->used + source.used > destination->size) {
+ status = private_f_type_uint64s_adjust(destination->used + source.used, destination);
+ if (F_status_is_error(status)) return status;
+ }
+
+ for (f_array_length_t i = 0; i < source.used; ++i, ++destination->used) {
+ destination->array[destination->used] = source.array[i];
+ } // for
+
+ return F_none;
+ }
+#endif // !defined(_di_f_type_uint64s_append_) || !defined(_di_f_type_uint64ss_append_)
+
+#if !defined(_di_f_type_uint64s_resize_) || !defined(_di_f_type_uint64s_append_) || !defined(_di_f_type_uint64s_decimate_by_) || !defined(_di_f_type_uint64ss_append_)
+ f_status_t private_f_type_uint64s_resize(const f_array_length_t length, f_uint64s_t *uint64s) {
+
+ const f_status_t status = f_memory_resize(uint64s->size, length, sizeof(f_uint64s_t), (void **) & uint64s->array);
+
+ if (F_status_is_error_not(status)) {
+ uint64s->size = length;
+
+ if (uint64s->used > uint64s->size) {
+ uint64s->used = length;
+ }
+ }
+
+ return status;
+ }
+#endif // !defined(_di_f_type_uint64s_resize_) || !defined(_di_f_type_uint64s_append_) || !defined(_di_f_type_uint64s_decimate_by_) || !defined(_di_f_type_uint64ss_append_)
#if !defined(_di_f_type_uint64ss_adjust_) || !defined(_di_f_type_uint64ss_decimate_by_)
f_status_t private_f_type_uint64ss_adjust(const f_array_length_t length, f_uint64ss_t *uint64ss) {
}
#endif // !defined(_di_f_type_uint64ss_adjust_) || !defined(_di_f_type_uint64ss_decimate_by_)
-#if !defined(_di_f_type_uint64ss_decrease_by_) || !defined(_di_f_type_uint64ss_increase_) || !defined(_di_f_type_uint64ss_increase_by_)
+#if !defined(_di_f_type_uint64ss_decrease_by_) || !defined(_di_f_type_uint64ss_increase_) || !defined(_di_f_type_uint64ss_increase_by_) || !defined(_di_f_type_uint64ss_resize_)
f_status_t private_f_type_uint64ss_resize(const f_array_length_t length, f_uint64ss_t *uint64ss) {
f_status_t status = F_none;
return status;
}
-#endif // !defined(_di_f_type_uint64ss_decrease_by_) || !defined(_di_f_type_uint64ss_increase_) || !defined(_di_f_type_uint64ss_increase_by_)
+#endif // !defined(_di_f_type_uint64ss_decrease_by_) || !defined(_di_f_type_uint64ss_increase_) || !defined(_di_f_type_uint64ss_increase_by_) || !defined(_di_f_type_uint64ss_resize_)
+
+#if !defined(_di_f_type_int128s_adjust_) || !defined(_di_f_type_int128s_decimate_by_)
+ f_status_t private_f_type_int128s_adjust(const f_array_length_t length, f_int128s_t *int128s) {
+
+ const f_status_t status = f_memory_adjust(int128s->size, length, sizeof(f_int128s_t), (void **) & int128s->array);
+
+ if (F_status_is_error_not(status)) {
+ int128s->size = length;
+
+ if (int128s->used > int128s->size) {
+ int128s->used = length;
+ }
+ }
+
+ return status;
+ }
+#endif // !defined(_di_f_type_int128s_adjust_) || !defined(_di_f_type_int128s_decimate_by_)
+
+#if !defined(_di_f_type_int128s_append_) || !defined(_di_f_type_int128ss_append_)
+ extern f_status_t private_f_type_int128s_append(const f_int128s_t source, f_int128s_t *destination) {
+ f_status_t status = F_none;
+
+ if (destination->used + source.used > destination->size) {
+ status = private_f_type_int128s_adjust(destination->used + source.used, destination);
+ if (F_status_is_error(status)) return status;
+ }
+
+ for (f_array_length_t i = 0; i < source.used; ++i, ++destination->used) {
+ destination->array[destination->used] = source.array[i];
+ } // for
+
+ return F_none;
+ }
+#endif // !defined(_di_f_type_int128s_append_) || !defined(_di_f_type_int128ss_append_)
+
+#if !defined(_di_f_type_int128s_resize_) || !defined(_di_f_type_int128s_append_) || !defined(_di_f_type_int128s_decimate_by_) || !defined(_di_f_type_int128ss_append_)
+ f_status_t private_f_type_int128s_resize(const f_array_length_t length, f_int128s_t *int128s) {
+
+ const f_status_t status = f_memory_resize(int128s->size, length, sizeof(f_int128s_t), (void **) & int128s->array);
+
+ if (F_status_is_error_not(status)) {
+ int128s->size = length;
+
+ if (int128s->used > int128s->size) {
+ int128s->used = length;
+ }
+ }
+
+ return status;
+ }
+#endif // !defined(_di_f_type_int128s_resize_) || !defined(_di_f_type_int128s_append_) || !defined(_di_f_type_int128s_decimate_by_) || !defined(_di_f_type_int128ss_append_)
#if !defined(_di_f_type_int128ss_adjust_) || !defined(_di_f_type_int128ss_decimate_by_)
f_status_t private_f_type_int128ss_adjust(const f_array_length_t length, f_int128ss_t *int128ss) {
}
#endif // !defined(_di_f_type_int128ss_adjust_) || !defined(_di_f_type_int128ss_decimate_by_)
-#if !defined(_di_f_type_int128ss_decrease_by_) || !defined(_di_f_type_int128ss_increase_) || !defined(_di_f_type_int128ss_increase_by_)
+#if !defined(_di_f_type_int128ss_decrease_by_) || !defined(_di_f_type_int128ss_increase_) || !defined(_di_f_type_int128ss_increase_by_) || !defined(_di_f_type_int128ss_resize_)
f_status_t private_f_type_int128ss_resize(const f_array_length_t length, f_int128ss_t *int128ss) {
f_status_t status = F_none;
return status;
}
-#endif // !defined(_di_f_type_int128ss_decrease_by_) || !defined(_di_f_type_int128ss_increase_) || !defined(_di_f_type_int128ss_increase_by_)
+#endif // !defined(_di_f_type_int128ss_decrease_by_) || !defined(_di_f_type_int128ss_increase_) || !defined(_di_f_type_int128ss_increase_by_) || !defined(_di_f_type_int128ss_resize_)
+
+#if !defined(_di_f_type_uint128s_adjust_) || !defined(_di_f_type_uint128s_decimate_by_)
+ f_status_t private_f_type_uint128s_adjust(const f_array_length_t length, f_uint128s_t *uint128s) {
+
+ const f_status_t status = f_memory_adjust(uint128s->size, length, sizeof(f_uint128s_t), (void **) & uint128s->array);
+
+ if (F_status_is_error_not(status)) {
+ uint128s->size = length;
+
+ if (uint128s->used > uint128s->size) {
+ uint128s->used = length;
+ }
+ }
+
+ return status;
+ }
+#endif // !defined(_di_f_type_uint128s_adjust_) || !defined(_di_f_type_uint128s_decimate_by_)
+
+#if !defined(_di_f_type_uint128s_append_) || !defined(_di_f_type_uint128ss_append_)
+ extern f_status_t private_f_type_uint128s_append(const f_uint128s_t source, f_uint128s_t *destination) {
+ f_status_t status = F_none;
+
+ if (destination->used + source.used > destination->size) {
+ status = private_f_type_uint128s_adjust(destination->used + source.used, destination);
+ if (F_status_is_error(status)) return status;
+ }
+
+ for (f_array_length_t i = 0; i < source.used; ++i, ++destination->used) {
+ destination->array[destination->used] = source.array[i];
+ } // for
+
+ return F_none;
+ }
+#endif // !defined(_di_f_type_uint128s_append_) || !defined(_di_f_type_uint128ss_append_)
+
+#if !defined(_di_f_type_uint128s_resize_) || !defined(_di_f_type_uint128s_append_) || !defined(_di_f_type_uint128s_decimate_by_) || !defined(_di_f_type_uint128ss_append_)
+ f_status_t private_f_type_uint128s_resize(const f_array_length_t length, f_uint128s_t *uint128s) {
+
+ const f_status_t status = f_memory_resize(uint128s->size, length, sizeof(f_uint128s_t), (void **) & uint128s->array);
+
+ if (F_status_is_error_not(status)) {
+ uint128s->size = length;
+
+ if (uint128s->used > uint128s->size) {
+ uint128s->used = length;
+ }
+ }
+
+ return status;
+ }
+#endif // !defined(_di_f_type_uint128s_resize_) || !defined(_di_f_type_uint128s_append_) || !defined(_di_f_type_uint128s_decimate_by_) || !defined(_di_f_type_uint128ss_append_)
#if !defined(_di_f_type_uint128ss_adjust_) || !defined(_di_f_type_uint128ss_decimate_by_)
f_status_t private_f_type_uint128ss_adjust(const f_array_length_t length, f_uint128ss_t *uint128ss) {
}
#endif // !defined(_di_f_type_uint128ss_adjust_) || !defined(_di_f_type_uint128ss_decimate_by_)
-#if !defined(_di_f_type_uint128ss_decrease_by_) || !defined(_di_f_type_uint128ss_increase_) || !defined(_di_f_type_uint128ss_increase_by_)
+#if !defined(_di_f_type_uint128ss_decrease_by_) || !defined(_di_f_type_uint128ss_increase_) || !defined(_di_f_type_uint128ss_increase_by_) || !defined(_di_f_type_uint128ss_resize_)
f_status_t private_f_type_uint128ss_resize(const f_array_length_t length, f_uint128ss_t *uint128ss) {
f_status_t status = F_none;
return status;
}
-#endif // !defined(_di_f_type_uint128ss_decrease_by_) || !defined(_di_f_type_uint128ss_increase_) || !defined(_di_f_type_uint128ss_increase_by_)
+#endif // !defined(_di_f_type_uint128ss_decrease_by_) || !defined(_di_f_type_uint128ss_increase_) || !defined(_di_f_type_uint128ss_increase_by_) || !defined(_di_f_type_uint128ss_resize_)
#ifdef __cplusplus
} // extern "C"
#endif
/**
+ * Private implementation for resizing the cells array.
+ *
+ * Intended to be shared to each of the different implementation variations.
+ *
+ * @param length
+ * The length to adjust to.
+ * @param cells
+ * The cells array to adjust.
+ *
+ * @return
+ * F_none on success.
+ * F_data_not on success, but there is no reason to increase size (used + 1 <= size).
+ *
+ * Errors (with error bit) from: f_memory_adjust().
+ *
+ * @see f_type_cells_adjust()
+ * @see f_type_cells_decimate_by()
+ */
+#if !defined(_di_f_type_cells_adjust_) || !defined(_di_f_type_cells_decimate_by_)
+ extern f_status_t private_f_type_cells_adjust(const f_array_length_t length, f_cells_t *cells) f_gcc_attribute_visibility_internal;
+#endif // !defined(_di_f_type_cells_adjust_) || !defined(_di_f_type_cells_decimate_by_)
+
+/**
+ * Private implementation for appending the cell array.
+ *
+ * Intended to be shared to each of the different implementation variations.
+ *
+ * @param source
+ * The source cells to append.
+ * @param destination
+ * The destination cells the source is appended onto.
+ *
+ * @return
+ * F_none on success.
+ *
+ * Errors (with error bit) from: f_memory_resize().
+ *
+ * @see f_type_cells_append()
+ * @see f_type_cellss_append()
+ */
+#if !defined(_di_f_type_cells_append_) || !defined(_di_f_type_cellss_append_)
+ extern f_status_t private_f_type_cells_append(const f_cells_t source, f_cells_t *destination) f_gcc_attribute_visibility_internal;
+#endif // !defined(_di_f_type_cells_append_) || !defined(_di_f_type_cellss_append_)
+
+/**
+ * Private implementation for resizing the cells array.
+ *
+ * Intended to be shared to each of the different implementation variations.
+ *
+ * @param length
+ * The length to adjust to.
+ * @param cells
+ * The cells array to adjust.
+ *
+ * @return
+ * F_none on success.
+ * F_data_not on success, but there is no reason to increase size (used + 1 <= size).
+ *
+ * Errors (with error bit) from: f_memory_resize().
+ *
+ * @see f_type_cells_resize()
+ * @see f_type_cells_append()
+ * @see f_type_cells_decimate_by()
+ * @see f_type_cellss_append()
+ */
+#if !defined(_di_f_type_cells_resize_) || !defined(_di_f_type_cells_append_) || !defined(_di_f_type_cells_decimate_by_) || !defined(_di_f_type_cellss_append_)
+ extern f_status_t private_f_type_cells_resize(const f_array_length_t length, f_cells_t *cells) f_gcc_attribute_visibility_internal;
+#endif // !defined(_di_f_type_cells_resize_) || !defined(_di_f_type_cells_append_) || !defined(_di_f_type_cells_decimate_by_) || !defined(_di_f_type_cellss_append_)
+
+/**
* Private implementation for resizing the cellss array.
*
* Intended to be shared to each of the different implementation variations.
* F_memory_not (with error bit) on out of memory.
* F_parameter (with error bit) if a parameter is invalid.
*
+ * Errors (with error bit) from: f_memory_adjust().
+ * Errors (with error bit) from: f_memory_destroy().
+ *
* @see f_type_cellss_adjust()
* @see f_type_cellss_decimate_by()
*/
* F_memory_not (with error bit) on out of memory.
* F_parameter (with error bit) if a parameter is invalid.
*
+ * Errors (with error bit) from: f_memory_delete().
+ * Errors (with error bit) from: f_memory_resize().
+ *
* @see f_type_cellss_decrease_by()
* @see f_type_cellss_increase()
* @see f_type_cellss_increase_by()
#endif // !defined(_di_f_type_cellss_decrease_by_) || !defined(_di_f_type_cellss_increase_) || !defined(_di_f_type_cellss_increase_by_) || !defined(_di_f_type_cellss_resize_)
/**
+ * Private implementation for resizing the array_lengths array.
+ *
+ * Intended to be shared to each of the different implementation variations.
+ *
+ * @param length
+ * The length to adjust to.
+ * @param lengths
+ * The lengths array to adjust.
+ *
+ * @return
+ * F_none on success.
+ * F_data_not on success, but there is no reason to increase size (used + 1 <= size).
+ *
+ * Errors (with error bit) from: f_memory_adjust().
+ *
+ * @see f_type_array_lengths_adjust()
+ * @see f_type_array_lengths_decimate_by()
+ */
+#if !defined(_di_f_type_array_lengths_adjust_) || !defined(_di_f_type_array_lengths_decimate_by_)
+ extern f_status_t private_f_type_array_lengths_adjust(const f_array_length_t length, f_array_lengths_t *lengths) f_gcc_attribute_visibility_internal;
+#endif // !defined(_di_f_type_array_lengths_adjust_) || !defined(_di_f_type_array_lengths_decimate_by_)
+
+/**
+ * Private implementation for appending the array_length array.
+ *
+ * Intended to be shared to each of the different implementation variations.
+ *
+ * @param source
+ * The source array_lengths to append.
+ * @param destination
+ * The destination lengths the source is appended onto.
+ *
+ * @return
+ * F_none on success.
+ *
+ * Errors (with error bit) from: f_memory_resize().
+ *
+ * @see f_type_array_lengths_append()
+ * @see f_type_array_lengthss_append()
+ */
+#if !defined(_di_f_type_array_lengths_append_) || !defined(_di_f_type_array_lengthss_append_)
+ extern f_status_t private_f_type_array_lengths_append(const f_array_lengths_t source, f_array_lengths_t *destination) f_gcc_attribute_visibility_internal;
+#endif // !defined(_di_f_type_array_lengths_append_) || !defined(_di_f_type_array_lengthss_append_)
+
+/**
+ * Private implementation for resizing the array_lengths array.
+ *
+ * Intended to be shared to each of the different implementation variations.
+ *
+ * @param length
+ * The length to adjust to.
+ * @param lengths
+ * The lengths array to adjust.
+ *
+ * @return
+ * F_none on success.
+ * F_data_not on success, but there is no reason to increase size (used + 1 <= size).
+ *
+ * Errors (with error bit) from: f_memory_resize().
+ *
+ * @see f_type_array_lengths_resize()
+ * @see f_type_array_lengths_append()
+ * @see f_type_array_lengths_decimate_by()
+ * @see f_type_array_lengthss_append()
+ */
+#if !defined(_di_f_type_array_lengths_resize_) || !defined(_di_f_type_array_lengths_append_) || !defined(_di_f_type_array_lengths_decimate_by_) || !defined(_di_f_type_array_lengthss_append_)
+ extern f_status_t private_f_type_array_lengths_resize(const f_array_length_t length, f_array_lengths_t *lengths) f_gcc_attribute_visibility_internal;
+#endif // !defined(_di_f_type_array_lengths_resize_) || !defined(_di_f_type_array_lengths_append_) || !defined(_di_f_type_array_lengths_decimate_by_) || !defined(_di_f_type_array_lengthss_append_)
+
+/**
* Private implementation for resizing the lengthss array.
*
* Intended to be shared to each of the different implementation variations.
* F_memory_not (with error bit) on out of memory.
* F_parameter (with error bit) if a parameter is invalid.
*
+ * Errors (with error bit) from: f_memory_adjust().
+ * Errors (with error bit) from: f_memory_destroy().
+ *
* @see f_type_array_lengthss_adjust()
* @see f_type_array_lengthss_decimate_by()
*/
* F_memory_not (with error bit) on out of memory.
* F_parameter (with error bit) if a parameter is invalid.
*
+ * Errors (with error bit) from: f_memory_delete().
+ * Errors (with error bit) from: f_memory_resize().
+ *
* @see f_type_array_lengthss_decrease_by()
* @see f_type_array_lengthss_increase()
* @see f_type_array_lengthss_increase_by()
#endif // !defined(_di_f_type_array_lengthss_decrease_by_) || !defined(_di_f_type_array_lengthss_increase_) || !defined(_di_f_type_array_lengthss_increase_by_) || !defined(_di_f_type_array_lengthss_resize_)
/**
+ * Private implementation for resizing the int8s array.
+ *
+ * Intended to be shared to each of the different implementation variations.
+ *
+ * @param length
+ * The length to adjust to.
+ * @param int8s
+ * The int8s array to adjust.
+ *
+ * @return
+ * F_none on success.
+ * F_data_not on success, but there is no reason to increase size (used + 1 <= size).
+ *
+ * Errors (with error bit) from: f_memory_adjust().
+ *
+ * @see f_type_int8s_adjust()
+ * @see f_type_int8s_decimate_by()
+ */
+#if !defined(_di_f_type_int8s_adjust_) || !defined(_di_f_type_int8s_decimate_by_)
+ extern f_status_t private_f_type_int8s_adjust(const f_array_length_t length, f_int8s_t *int8s) f_gcc_attribute_visibility_internal;
+#endif // !defined(_di_f_type_int8s_adjust_) || !defined(_di_f_type_int8s_decimate_by_)
+
+/**
+ * Private implementation for appending the int8 array.
+ *
+ * Intended to be shared to each of the different implementation variations.
+ *
+ * @param source
+ * The source int8s to append.
+ * @param destination
+ * The destination int8s the source is appended onto.
+ *
+ * @return
+ * F_none on success.
+ *
+ * Errors (with error bit) from: f_memory_resize().
+ *
+ * @see f_type_int8s_append()
+ * @see f_type_int8ss_append()
+ */
+#if !defined(_di_f_type_int8s_append_) || !defined(_di_f_type_int8ss_append_)
+ extern f_status_t private_f_type_int8s_append(const f_int8s_t source, f_int8s_t *destination) f_gcc_attribute_visibility_internal;
+#endif // !defined(_di_f_type_int8s_append_) || !defined(_di_f_type_int8ss_append_)
+
+/**
+ * Private implementation for resizing the int8s array.
+ *
+ * Intended to be shared to each of the different implementation variations.
+ *
+ * @param length
+ * The length to adjust to.
+ * @param int8s
+ * The int8s array to adjust.
+ *
+ * @return
+ * F_none on success.
+ * F_data_not on success, but there is no reason to increase size (used + 1 <= size).
+ *
+ * Errors (with error bit) from: f_memory_resize().
+ *
+ * @see f_type_int8s_resize()
+ * @see f_type_int8s_append()
+ * @see f_type_int8s_decimate_by()
+ * @see f_type_int8ss_append()
+ */
+#if !defined(_di_f_type_int8s_resize_) || !defined(_di_f_type_int8s_append_) || !defined(_di_f_type_int8s_decimate_by_) || !defined(_di_f_type_int8ss_append_)
+ extern f_status_t private_f_type_int8s_resize(const f_array_length_t length, f_int8s_t *int8s) f_gcc_attribute_visibility_internal;
+#endif // !defined(_di_f_type_int8s_resize_) || !defined(_di_f_type_int8s_append_) || !defined(_di_f_type_int8s_decimate_by_) || !defined(_di_f_type_int8ss_append_)
+
+/**
* Private implementation for resizing the int8ss array.
*
* Intended to be shared to each of the different implementation variations.
* F_memory_not (with error bit) on out of memory.
* F_parameter (with error bit) if a parameter is invalid.
*
+ * Errors (with error bit) from: f_memory_adjust().
+ * Errors (with error bit) from: f_memory_destroy().
+ *
* @see f_type_int8ss_adjust()
* @see f_type_int8ss_decimate_by()
*/
* F_memory_not (with error bit) on out of memory.
* F_parameter (with error bit) if a parameter is invalid.
*
+ * Errors (with error bit) from: f_memory_delete().
+ * Errors (with error bit) from: f_memory_resize().
+ *
* @see f_type_int8ss_decrease_by()
* @see f_type_int8ss_increase()
* @see f_type_int8ss_increase_by()
#endif // !defined(_di_f_type_int8ss_decrease_by_) || !defined(_di_f_type_int8ss_increase_) || !defined(_di_f_type_int8ss_increase_by_) || !defined(_di_f_type_int8ss_resize_)
/**
+ * Private implementation for resizing the uint8s array.
+ *
+ * Intended to be shared to each of the different implementation variations.
+ *
+ * @param length
+ * The length to adjust to.
+ * @param uint8s
+ * The uint8s array to adjust.
+ *
+ * @return
+ * F_none on success.
+ * F_data_not on success, but there is no reason to increase size (used + 1 <= size).
+ *
+ * Errors (with error bit) from: f_memory_adjust().
+ *
+ * @see f_type_uint8s_adjust()
+ * @see f_type_uint8s_decimate_by()
+ */
+#if !defined(_di_f_type_uint8s_adjust_) || !defined(_di_f_type_uint8s_decimate_by_)
+ extern f_status_t private_f_type_uint8s_adjust(const f_array_length_t length, f_uint8s_t *uint8s) f_gcc_attribute_visibility_internal;
+#endif // !defined(_di_f_type_uint8s_adjust_) || !defined(_di_f_type_uint8s_decimate_by_)
+
+/**
+ * Private implementation for appending the uint8 array.
+ *
+ * Intended to be shared to each of the different implementation variations.
+ *
+ * @param source
+ * The source uint8s to append.
+ * @param destination
+ * The destination uint8s the source is appended onto.
+ *
+ * @return
+ * F_none on success.
+ *
+ * Errors (with error bit) from: f_memory_resize().
+ *
+ * @see f_type_uint8s_append()
+ * @see f_type_uint8ss_append()
+ */
+#if !defined(_di_f_type_uint8s_append_) || !defined(_di_f_type_uint8ss_append_)
+ extern f_status_t private_f_type_uint8s_append(const f_uint8s_t source, f_uint8s_t *destination) f_gcc_attribute_visibility_internal;
+#endif // !defined(_di_f_type_uint8s_append_) || !defined(_di_f_type_uint8ss_append_)
+
+/**
+ * Private implementation for resizing the uint8s array.
+ *
+ * Intended to be shared to each of the different implementation variations.
+ *
+ * @param length
+ * The length to adjust to.
+ * @param uint8s
+ * The uint8s array to adjust.
+ *
+ * @return
+ * F_none on success.
+ * F_data_not on success, but there is no reason to increase size (used + 1 <= size).
+ *
+ * Errors (with error bit) from: f_memory_resize().
+ *
+ * @see f_type_uint8s_resize()
+ * @see f_type_uint8s_append()
+ * @see f_type_uint8s_decimate_by()
+ * @see f_type_uint8ss_append()
+ */
+#if !defined(_di_f_type_uint8s_resize_) || !defined(_di_f_type_uint8s_append_) || !defined(_di_f_type_uint8s_decimate_by_) || !defined(_di_f_type_uint8ss_append_)
+ extern f_status_t private_f_type_uint8s_resize(const f_array_length_t length, f_uint8s_t *uint8s) f_gcc_attribute_visibility_internal;
+#endif // !defined(_di_f_type_uint8s_resize_) || !defined(_di_f_type_uint8s_append_) || !defined(_di_f_type_uint8s_decimate_by_) || !defined(_di_f_type_uint8ss_append_)
+
+/**
* Private implementation for resizing the uint8ss array.
*
* Intended to be shared to each of the different implementation variations.
* F_memory_not (with error bit) on out of memory.
* F_parameter (with error bit) if a parameter is invalid.
*
+ * Errors (with error bit) from: f_memory_adjust().
+ * Errors (with error bit) from: f_memory_destroy().
+ *
* @see f_type_uint8ss_adjust()
* @see f_type_uint8ss_decimate_by()
*/
-#if !defined(_di_f_type_int16ss_adjust_) || !defined(_di_f_type_int16ss_decimate_by_)
+#if !defined(_di_f_type_uint8ss_adjust_) || !defined(_di_f_type_uint8ss_decimate_by_)
extern f_status_t private_f_type_uint8ss_adjust(const f_array_length_t length, f_uint8ss_t *uint8ss) f_gcc_attribute_visibility_internal;
-#endif // !defined(_di_f_type_int16ss_adjust_) || !defined(_di_f_type_int16ss_decimate_by_)
+#endif // !defined(_di_f_type_uint8ss_adjust_) || !defined(_di_f_type_uint8ss_decimate_by_)
/**
* Private implementation for resizing the uint8ss array.
* F_memory_not (with error bit) on out of memory.
* F_parameter (with error bit) if a parameter is invalid.
*
+ * Errors (with error bit) from: f_memory_delete().
+ * Errors (with error bit) from: f_memory_resize().
+ *
* @see f_type_uint8ss_decrease_by()
* @see f_type_uint8ss_increase()
* @see f_type_uint8ss_increase_by()
#endif // !defined(_di_f_type_uint8ss_decrease_by_) || !defined(_di_f_type_uint8ss_increase_) || !defined(_di_f_type_uint8ss_increase_by_) || !defined(_di_f_type_uint8ss_resize_)
/**
+ * Private implementation for resizing the int16s array.
+ *
+ * Intended to be shared to each of the different implementation variations.
+ *
+ * @param length
+ * The length to adjust to.
+ * @param int16s
+ * The int16s array to adjust.
+ *
+ * @return
+ * F_none on success.
+ * F_data_not on success, but there is no reason to increase size (used + 1 <= size).
+ *
+ * Errors (with error bit) from: f_memory_adjust().
+ *
+ * @see f_type_int16s_adjust()
+ * @see f_type_int16s_decimate_by()
+ */
+#if !defined(_di_f_type_int16s_adjust_) || !defined(_di_f_type_int16s_decimate_by_)
+ extern f_status_t private_f_type_int16s_adjust(const f_array_length_t length, f_int16s_t *int16s) f_gcc_attribute_visibility_internal;
+#endif // !defined(_di_f_type_int16s_adjust_) || !defined(_di_f_type_int16s_decimate_by_)
+
+/**
+ * Private implementation for appending the int16 array.
+ *
+ * Intended to be shared to each of the different implementation variations.
+ *
+ * @param source
+ * The source int16s to append.
+ * @param destination
+ * The destination int16s the source is appended onto.
+ *
+ * @return
+ * F_none on success.
+ *
+ * Errors (with error bit) from: f_memory_resize().
+ *
+ * @see f_type_int16s_append()
+ * @see f_type_int16ss_append()
+ */
+#if !defined(_di_f_type_int16s_append_) || !defined(_di_f_type_int16ss_append_)
+ extern f_status_t private_f_type_int16s_append(const f_int16s_t source, f_int16s_t *destination) f_gcc_attribute_visibility_internal;
+#endif // !defined(_di_f_type_int16s_append_) || !defined(_di_f_type_int16ss_append_)
+
+/**
+ * Private implementation for resizing the int16s array.
+ *
+ * Intended to be shared to each of the different implementation variations.
+ *
+ * @param length
+ * The length to adjust to.
+ * @param int16s
+ * The int16s array to adjust.
+ *
+ * @return
+ * F_none on success.
+ * F_data_not on success, but there is no reason to increase size (used + 1 <= size).
+ *
+ * Errors (with error bit) from: f_memory_resize().
+ *
+ * @see f_type_int16s_resize()
+ * @see f_type_int16s_append()
+ * @see f_type_int16s_decimate_by()
+ * @see f_type_int16ss_append()
+ */
+#if !defined(_di_f_type_int16s_resize_) || !defined(_di_f_type_int16s_append_) || !defined(_di_f_type_int16s_decimate_by_) || !defined(_di_f_type_int16ss_append_)
+ extern f_status_t private_f_type_int16s_resize(const f_array_length_t length, f_int16s_t *int16s) f_gcc_attribute_visibility_internal;
+#endif // !defined(_di_f_type_int16s_resize_) || !defined(_di_f_type_int16s_append_) || !defined(_di_f_type_int16s_decimate_by_) || !defined(_di_f_type_int16ss_append_)
+
+/**
* Private implementation for resizing the int16ss array.
*
* Intended to be shared to each of the different implementation variations.
* F_memory_not (with error bit) on out of memory.
* F_parameter (with error bit) if a parameter is invalid.
*
+ * Errors (with error bit) from: f_memory_adjust().
+ * Errors (with error bit) from: f_memory_destroy().
+ *
* @see f_type_int16ss_adjust()
* @see f_type_int16ss_decimate_by()
*/
* F_memory_not (with error bit) on out of memory.
* F_parameter (with error bit) if a parameter is invalid.
*
+ * Errors (with error bit) from: f_memory_delete().
+ * Errors (with error bit) from: f_memory_resize().
+ *
* @see f_type_int16ss_decrease_by()
* @see f_type_int16ss_increase()
* @see f_type_int16ss_increase_by()
#endif // !defined(_di_f_type_int16ss_decrease_by_) || !defined(_di_f_type_int16ss_increase_) || !defined(_di_f_type_int16ss_increase_by_) || !defined(_di_f_type_int16ss_resize_)
/**
+ * Private implementation for resizing the uint16s array.
+ *
+ * Intended to be shared to each of the different implementation variations.
+ *
+ * @param length
+ * The length to adjust to.
+ * @param uint16s
+ * The uint16s array to adjust.
+ *
+ * @return
+ * F_none on success.
+ * F_data_not on success, but there is no reason to increase size (used + 1 <= size).
+ *
+ * Errors (with error bit) from: f_memory_adjust().
+ *
+ * @see f_type_uint16s_adjust()
+ * @see f_type_uint16s_decimate_by()
+ */
+#if !defined(_di_f_type_uint16s_adjust_) || !defined(_di_f_type_uint16s_decimate_by_)
+ extern f_status_t private_f_type_uint16s_adjust(const f_array_length_t length, f_uint16s_t *uint16s) f_gcc_attribute_visibility_internal;
+#endif // !defined(_di_f_type_uint16s_adjust_) || !defined(_di_f_type_uint16s_decimate_by_)
+
+/**
+ * Private implementation for appending the uint16 array.
+ *
+ * Intended to be shared to each of the different implementation variations.
+ *
+ * @param source
+ * The source uint16s to append.
+ * @param destination
+ * The destination uint16s the source is appended onto.
+ *
+ * @return
+ * F_none on success.
+ *
+ * Errors (with error bit) from: f_memory_resize().
+ *
+ * @see f_type_uint16s_append()
+ * @see f_type_uint16ss_append()
+ */
+#if !defined(_di_f_type_uint16s_append_) || !defined(_di_f_type_uint16ss_append_)
+ extern f_status_t private_f_type_uint16s_append(const f_uint16s_t source, f_uint16s_t *destination) f_gcc_attribute_visibility_internal;
+#endif // !defined(_di_f_type_uint16s_append_) || !defined(_di_f_type_uint16ss_append_)
+
+/**
+ * Private implementation for resizing the uint16s array.
+ *
+ * Intended to be shared to each of the different implementation variations.
+ *
+ * @param length
+ * The length to adjust to.
+ * @param uint16s
+ * The uint16s array to adjust.
+ *
+ * @return
+ * F_none on success.
+ * F_data_not on success, but there is no reason to increase size (used + 1 <= size).
+ *
+ * Errors (with error bit) from: f_memory_resize().
+ *
+ * @see f_type_uint16s_resize()
+ * @see f_type_uint16s_append()
+ * @see f_type_uint16s_decimate_by()
+ * @see f_type_uint16ss_append()
+ */
+#if !defined(_di_f_type_uint16s_resize_) || !defined(_di_f_type_uint16s_append_) || !defined(_di_f_type_uint16s_decimate_by_) || !defined(_di_f_type_uint16ss_append_)
+ extern f_status_t private_f_type_uint16s_resize(const f_array_length_t length, f_uint16s_t *uint16s) f_gcc_attribute_visibility_internal;
+#endif // !defined(_di_f_type_uint16s_resize_) || !defined(_di_f_type_uint16s_append_) || !defined(_di_f_type_uint16s_decimate_by_) || !defined(_di_f_type_uint16ss_append_)
+
+/**
* Private implementation for resizing the uint16ss array.
*
* Intended to be shared to each of the different implementation variations.
* F_memory_not (with error bit) on out of memory.
* F_parameter (with error bit) if a parameter is invalid.
*
+ * Errors (with error bit) from: f_memory_adjust().
+ * Errors (with error bit) from: f_memory_destroy().
+ *
* @see f_type_uint16ss_adjust()
* @see f_type_uint16ss_decimate_by()
*/
* F_memory_not (with error bit) on out of memory.
* F_parameter (with error bit) if a parameter is invalid.
*
+ * Errors (with error bit) from: f_memory_delete().
+ * Errors (with error bit) from: f_memory_resize().
+ *
* @see f_type_uint16ss_decrease_by()
* @see f_type_uint16ss_increase()
* @see f_type_uint16ss_increase_by()
#endif // !defined(_di_f_type_uint16ss_decrease_by_) || !defined(_di_f_type_uint16ss_increase_) || !defined(_di_f_type_uint16ss_increase_by_) || !defined(_di_f_type_uint16ss_resize_)
/**
+ * Private implementation for resizing the int32s array.
+ *
+ * Intended to be shared to each of the different implementation variations.
+ *
+ * @param length
+ * The length to adjust to.
+ * @param int32s
+ * The int32s array to adjust.
+ *
+ * @return
+ * F_none on success.
+ * F_data_not on success, but there is no reason to increase size (used + 1 <= size).
+ *
+ * Errors (with error bit) from: f_memory_adjust().
+ *
+ * @see f_type_int32s_adjust()
+ * @see f_type_int32s_decimate_by()
+ */
+#if !defined(_di_f_type_int32s_adjust_) || !defined(_di_f_type_int32s_decimate_by_)
+ extern f_status_t private_f_type_int32s_adjust(const f_array_length_t length, f_int32s_t *int32s) f_gcc_attribute_visibility_internal;
+#endif // !defined(_di_f_type_int32s_adjust_) || !defined(_di_f_type_int32s_decimate_by_)
+
+/**
+ * Private implementation for appending the int32 array.
+ *
+ * Intended to be shared to each of the different implementation variations.
+ *
+ * @param source
+ * The source int32s to append.
+ * @param destination
+ * The destination int32s the source is appended onto.
+ *
+ * @return
+ * F_none on success.
+ *
+ * Errors (with error bit) from: f_memory_resize().
+ *
+ * @see f_type_int32s_append()
+ * @see f_type_int32ss_append()
+ */
+#if !defined(_di_f_type_int32s_append_) || !defined(_di_f_type_int32ss_append_)
+ extern f_status_t private_f_type_int32s_append(const f_int32s_t source, f_int32s_t *destination) f_gcc_attribute_visibility_internal;
+#endif // !defined(_di_f_type_int32s_append_) || !defined(_di_f_type_int32ss_append_)
+
+/**
+ * Private implementation for resizing the int32s array.
+ *
+ * Intended to be shared to each of the different implementation variations.
+ *
+ * @param length
+ * The length to adjust to.
+ * @param int32s
+ * The int32s array to adjust.
+ *
+ * @return
+ * F_none on success.
+ * F_data_not on success, but there is no reason to increase size (used + 1 <= size).
+ *
+ * Errors (with error bit) from: f_memory_resize().
+ *
+ * @see f_type_int32s_resize()
+ * @see f_type_int32s_append()
+ * @see f_type_int32s_decimate_by()
+ * @see f_type_int32ss_append()
+ */
+#if !defined(_di_f_type_int32s_resize_) || !defined(_di_f_type_int32s_append_) || !defined(_di_f_type_int32s_decimate_by_) || !defined(_di_f_type_int32ss_append_)
+ extern f_status_t private_f_type_int32s_resize(const f_array_length_t length, f_int32s_t *int32s) f_gcc_attribute_visibility_internal;
+#endif // !defined(_di_f_type_int32s_resize_) || !defined(_di_f_type_int32s_append_) || !defined(_di_f_type_int32s_decimate_by_) || !defined(_di_f_type_int32ss_append_)
+
+/**
* Private implementation for resizing the int32ss array.
*
* Intended to be shared to each of the different implementation variations.
* F_memory_not (with error bit) on out of memory.
* F_parameter (with error bit) if a parameter is invalid.
*
+ * Errors (with error bit) from: f_memory_adjust().
+ * Errors (with error bit) from: f_memory_destroy().
+ *
* @see f_type_int32ss_adjust()
* @see f_type_int32ss_decimate_by()
*/
* F_memory_not (with error bit) on out of memory.
* F_parameter (with error bit) if a parameter is invalid.
*
+ * Errors (with error bit) from: f_memory_delete().
+ * Errors (with error bit) from: f_memory_resize().
+ *
* @see f_type_int32ss_decrease_by()
* @see f_type_int32ss_increase()
* @see f_type_int32ss_increase_by()
#endif // !defined(_di_f_type_int32ss_decrease_by_) || !defined(_di_f_type_int32ss_increase_) || !defined(_di_f_type_int32ss_increase_by_) || !defined(_di_f_type_int32ss_resize_)
/**
+ * Private implementation for resizing the uint32s array.
+ *
+ * Intended to be shared to each of the different implementation variations.
+ *
+ * @param length
+ * The length to adjust to.
+ * @param uint32s
+ * The uint32s array to adjust.
+ *
+ * @return
+ * F_none on success.
+ * F_data_not on success, but there is no reason to increase size (used + 1 <= size).
+ *
+ * Errors (with error bit) from: f_memory_adjust().
+ *
+ * @see f_type_uint32s_adjust()
+ * @see f_type_uint32s_decimate_by()
+ */
+#if !defined(_di_f_type_uint32s_adjust_) || !defined(_di_f_type_uint32s_decimate_by_)
+ extern f_status_t private_f_type_uint32s_adjust(const f_array_length_t length, f_uint32s_t *uint32s) f_gcc_attribute_visibility_internal;
+#endif // !defined(_di_f_type_uint32s_adjust_) || !defined(_di_f_type_uint32s_decimate_by_)
+
+/**
+ * Private implementation for appending the uint32 array.
+ *
+ * Intended to be shared to each of the different implementation variations.
+ *
+ * @param source
+ * The source uint32s to append.
+ * @param destination
+ * The destination uint32s the source is appended onto.
+ *
+ * @return
+ * F_none on success.
+ *
+ * Errors (with error bit) from: f_memory_resize().
+ *
+ * @see f_type_uint32s_append()
+ * @see f_type_uint32ss_append()
+ */
+#if !defined(_di_f_type_uint32s_append_) || !defined(_di_f_type_uint32ss_append_)
+ extern f_status_t private_f_type_uint32s_append(const f_uint32s_t source, f_uint32s_t *destination) f_gcc_attribute_visibility_internal;
+#endif // !defined(_di_f_type_uint32s_append_) || !defined(_di_f_type_uint32ss_append_)
+
+/**
+ * Private implementation for resizing the uint32s array.
+ *
+ * Intended to be shared to each of the different implementation variations.
+ *
+ * @param length
+ * The length to adjust to.
+ * @param uint32s
+ * The uint32s array to adjust.
+ *
+ * @return
+ * F_none on success.
+ * F_data_not on success, but there is no reason to increase size (used + 1 <= size).
+ *
+ * Errors (with error bit) from: f_memory_resize().
+ *
+ * @see f_type_uint32s_resize()
+ * @see f_type_uint32s_append()
+ * @see f_type_uint32s_decimate_by()
+ * @see f_type_uint32ss_append()
+ */
+#if !defined(_di_f_type_uint32s_resize_) || !defined(_di_f_type_uint32s_append_) || !defined(_di_f_type_uint32s_decimate_by_) || !defined(_di_f_type_uint32ss_append_)
+ extern f_status_t private_f_type_uint32s_resize(const f_array_length_t length, f_uint32s_t *uint32s) f_gcc_attribute_visibility_internal;
+#endif // !defined(_di_f_type_uint32s_resize_) || !defined(_di_f_type_uint32s_append_) || !defined(_di_f_type_uint32s_decimate_by_) || !defined(_di_f_type_uint32ss_append_)
+
+/**
* Private implementation for resizing the uint32ss array.
*
* Intended to be shared to each of the different implementation variations.
* F_memory_not (with error bit) on out of memory.
* F_parameter (with error bit) if a parameter is invalid.
*
+ * Errors (with error bit) from: f_memory_adjust().
+ * Errors (with error bit) from: f_memory_destroy().
+ *
* @see f_type_uint32ss_adjust()
* @see f_type_uint32ss_decimate_by()
*/
* F_memory_not (with error bit) on out of memory.
* F_parameter (with error bit) if a parameter is invalid.
*
+ * Errors (with error bit) from: f_memory_delete().
+ * Errors (with error bit) from: f_memory_resize().
+ *
* @see f_type_uint32ss_decrease_by()
* @see f_type_uint32ss_increase()
* @see f_type_uint32ss_increase_by()
#endif // !defined(_di_f_type_uint32ss_decrease_by_) || !defined(_di_f_type_uint32ss_increase_) || !defined(_di_f_type_uint32ss_increase_by_) || !defined(_di_f_type_uint32ss_resize_)
/**
+ * Private implementation for resizing the int64s array.
+ *
+ * Intended to be shared to each of the different implementation variations.
+ *
+ * @param length
+ * The length to adjust to.
+ * @param int64s
+ * The int64s array to adjust.
+ *
+ * @return
+ * F_none on success.
+ * F_data_not on success, but there is no reason to increase size (used + 1 <= size).
+ *
+ * Errors (with error bit) from: f_memory_adjust().
+ *
+ * @see f_type_int64s_adjust()
+ * @see f_type_int64s_decimate_by()
+ */
+#if !defined(_di_f_type_int64s_adjust_) || !defined(_di_f_type_int64s_decimate_by_)
+ extern f_status_t private_f_type_int64s_adjust(const f_array_length_t length, f_int64s_t *int64s) f_gcc_attribute_visibility_internal;
+#endif // !defined(_di_f_type_int64s_adjust_) || !defined(_di_f_type_int64s_decimate_by_)
+
+/**
+ * Private implementation for appending the int64 array.
+ *
+ * Intended to be shared to each of the different implementation variations.
+ *
+ * @param source
+ * The source int64s to append.
+ * @param destination
+ * The destination int64s the source is appended onto.
+ *
+ * @return
+ * F_none on success.
+ *
+ * Errors (with error bit) from: f_memory_resize().
+ *
+ * @see f_type_int64s_append()
+ * @see f_type_int64ss_append()
+ */
+#if !defined(_di_f_type_int64s_append_) || !defined(_di_f_type_int64ss_append_)
+ extern f_status_t private_f_type_int64s_append(const f_int64s_t source, f_int64s_t *destination) f_gcc_attribute_visibility_internal;
+#endif // !defined(_di_f_type_int64s_append_) || !defined(_di_f_type_int64ss_append_)
+
+/**
+ * Private implementation for resizing the int64s array.
+ *
+ * Intended to be shared to each of the different implementation variations.
+ *
+ * @param length
+ * The length to adjust to.
+ * @param int64s
+ * The int64s array to adjust.
+ *
+ * @return
+ * F_none on success.
+ * F_data_not on success, but there is no reason to increase size (used + 1 <= size).
+ *
+ * Errors (with error bit) from: f_memory_resize().
+ *
+ * @see f_type_int64s_resize()
+ * @see f_type_int64s_append()
+ * @see f_type_int64s_decimate_by()
+ * @see f_type_int64ss_append()
+ */
+#if !defined(_di_f_type_int64s_resize_) || !defined(_di_f_type_int64s_append_) || !defined(_di_f_type_int64s_decimate_by_) || !defined(_di_f_type_int64ss_append_)
+ extern f_status_t private_f_type_int64s_resize(const f_array_length_t length, f_int64s_t *int64s) f_gcc_attribute_visibility_internal;
+#endif // !defined(_di_f_type_int64s_resize_) || !defined(_di_f_type_int64s_append_) || !defined(_di_f_type_int64s_decimate_by_) || !defined(_di_f_type_int64ss_append_)
+
+/**
* Private implementation for resizing the int64ss array.
*
* Intended to be shared to each of the different implementation variations.
* F_memory_not (with error bit) on out of memory.
* F_parameter (with error bit) if a parameter is invalid.
*
+ * Errors (with error bit) from: f_memory_adjust().
+ * Errors (with error bit) from: f_memory_destroy().
+ *
* @see f_type_int64ss_adjust()
* @see f_type_int64ss_decimate_by()
*/
* F_memory_not (with error bit) on out of memory.
* F_parameter (with error bit) if a parameter is invalid.
*
+ * Errors (with error bit) from: f_memory_delete().
+ * Errors (with error bit) from: f_memory_resize().
+ *
* @see f_type_int64ss_decrease_by()
* @see f_type_int64ss_increase()
* @see f_type_int64ss_increase_by()
#endif // !defined(_di_f_type_int64ss_decrease_by_) || !defined(_di_f_type_int64ss_increase_) || !defined(_di_f_type_int64ss_increase_by_) || !defined(_di_f_type_int64ss_resize_)
/**
+ * Private implementation for resizing the uint64s array.
+ *
+ * Intended to be shared to each of the different implementation variations.
+ *
+ * @param length
+ * The length to adjust to.
+ * @param uint64s
+ * The uint64s array to adjust.
+ *
+ * @return
+ * F_none on success.
+ * F_data_not on success, but there is no reason to increase size (used + 1 <= size).
+ *
+ * Errors (with error bit) from: f_memory_adjust().
+ *
+ * @see f_type_uint64s_adjust()
+ * @see f_type_uint64s_decimate_by()
+ */
+#if !defined(_di_f_type_uint64s_adjust_) || !defined(_di_f_type_uint64s_decimate_by_)
+ extern f_status_t private_f_type_uint64s_adjust(const f_array_length_t length, f_uint64s_t *uint64s) f_gcc_attribute_visibility_internal;
+#endif // !defined(_di_f_type_uint64s_adjust_) || !defined(_di_f_type_uint64s_decimate_by_)
+
+/**
+ * Private implementation for appending the uint64 array.
+ *
+ * Intended to be shared to each of the different implementation variations.
+ *
+ * @param source
+ * The source uint64s to append.
+ * @param destination
+ * The destination uint64s the source is appended onto.
+ *
+ * @return
+ * F_none on success.
+ *
+ * Errors (with error bit) from: f_memory_resize().
+ *
+ * @see f_type_uint64s_append()
+ * @see f_type_uint64ss_append()
+ */
+#if !defined(_di_f_type_uint64s_append_) || !defined(_di_f_type_uint64ss_append_)
+ extern f_status_t private_f_type_uint64s_append(const f_uint64s_t source, f_uint64s_t *destination) f_gcc_attribute_visibility_internal;
+#endif // !defined(_di_f_type_uint64s_append_) || !defined(_di_f_type_uint64ss_append_)
+
+/**
+ * Private implementation for resizing the uint64s array.
+ *
+ * Intended to be shared to each of the different implementation variations.
+ *
+ * @param length
+ * The length to adjust to.
+ * @param uint64s
+ * The uint64s array to adjust.
+ *
+ * @return
+ * F_none on success.
+ * F_data_not on success, but there is no reason to increase size (used + 1 <= size).
+ *
+ * Errors (with error bit) from: f_memory_resize().
+ *
+ * @see f_type_uint64s_resize()
+ * @see f_type_uint64s_append()
+ * @see f_type_uint64s_decimate_by()
+ * @see f_type_uint64ss_append()
+ */
+#if !defined(_di_f_type_uint64s_resize_) || !defined(_di_f_type_uint64s_append_) || !defined(_di_f_type_uint64s_decimate_by_) || !defined(_di_f_type_uint64ss_append_)
+ extern f_status_t private_f_type_uint64s_resize(const f_array_length_t length, f_uint64s_t *uint64s) f_gcc_attribute_visibility_internal;
+#endif // !defined(_di_f_type_uint64s_resize_) || !defined(_di_f_type_uint64s_append_) || !defined(_di_f_type_uint64s_decimate_by_) || !defined(_di_f_type_uint64ss_append_)
+
+/**
* Private implementation for resizing the uint64ss array.
*
* Intended to be shared to each of the different implementation variations.
* F_memory_not (with error bit) on out of memory.
* F_parameter (with error bit) if a parameter is invalid.
*
+ * Errors (with error bit) from: f_memory_adjust().
+ * Errors (with error bit) from: f_memory_destroy().
+ *
* @see f_type_uint64ss_adjust()
* @see f_type_uint64ss_decimate_by()
*/
* F_memory_not (with error bit) on out of memory.
* F_parameter (with error bit) if a parameter is invalid.
*
+ * Errors (with error bit) from: f_memory_delete().
+ * Errors (with error bit) from: f_memory_resize().
+ *
* @see f_type_uint64ss_decrease_by()
* @see f_type_uint64ss_increase()
* @see f_type_uint64ss_increase_by()
#endif // !defined(_di_f_type_uint64ss_decrease_by_) || !defined(_di_f_type_uint64ss_increase_) || !defined(_di_f_type_uint64ss_increase_by_) || !defined(_di_f_type_uint64ss_resize_)
/**
+ * Private implementation for resizing the int128s array.
+ *
+ * Intended to be shared to each of the different implementation variations.
+ *
+ * @param length
+ * The length to adjust to.
+ * @param int128s
+ * The int128s array to adjust.
+ *
+ * @return
+ * F_none on success.
+ * F_data_not on success, but there is no reason to increase size (used + 1 <= size).
+ *
+ * Errors (with error bit) from: f_memory_adjust().
+ *
+ * @see f_type_int128s_adjust()
+ * @see f_type_int128s_decimate_by()
+ */
+#if !defined(_di_f_type_int128s_adjust_) || !defined(_di_f_type_int128s_decimate_by_)
+ extern f_status_t private_f_type_int128s_adjust(const f_array_length_t length, f_int128s_t *int128s) f_gcc_attribute_visibility_internal;
+#endif // !defined(_di_f_type_int128s_adjust_) || !defined(_di_f_type_int128s_decimate_by_)
+
+/**
+ * Private implementation for appending the int128 array.
+ *
+ * Intended to be shared to each of the different implementation variations.
+ *
+ * @param source
+ * The source int128s to append.
+ * @param destination
+ * The destination int128s the source is appended onto.
+ *
+ * @return
+ * F_none on success.
+ *
+ * Errors (with error bit) from: f_memory_resize().
+ *
+ * @see f_type_int128s_append()
+ * @see f_type_int128ss_append()
+ */
+#if !defined(_di_f_type_int128s_append_) || !defined(_di_f_type_int128ss_append_)
+ extern f_status_t private_f_type_int128s_append(const f_int128s_t source, f_int128s_t *destination) f_gcc_attribute_visibility_internal;
+#endif // !defined(_di_f_type_int128s_append_) || !defined(_di_f_type_int128ss_append_)
+
+/**
+ * Private implementation for resizing the int128s array.
+ *
+ * Intended to be shared to each of the different implementation variations.
+ *
+ * @param length
+ * The length to adjust to.
+ * @param int128s
+ * The int128s array to adjust.
+ *
+ * @return
+ * F_none on success.
+ * F_data_not on success, but there is no reason to increase size (used + 1 <= size).
+ *
+ * Errors (with error bit) from: f_memory_resize().
+ *
+ * @see f_type_int128s_resize()
+ * @see f_type_int128s_append()
+ * @see f_type_int128s_decimate_by()
+ * @see f_type_int128ss_append()
+ */
+#if !defined(_di_f_type_int128s_resize_) || !defined(_di_f_type_int128s_append_) || !defined(_di_f_type_int128s_decimate_by_) || !defined(_di_f_type_int128ss_append_)
+ extern f_status_t private_f_type_int128s_resize(const f_array_length_t length, f_int128s_t *int128s) f_gcc_attribute_visibility_internal;
+#endif // !defined(_di_f_type_int128s_resize_) || !defined(_di_f_type_int128s_append_) || !defined(_di_f_type_int128s_decimate_by_) || !defined(_di_f_type_int128ss_append_)
+
+/**
* Private implementation for resizing the int128ss array.
*
* Intended to be shared to each of the different implementation variations.
* F_memory_not (with error bit) on out of memory.
* F_parameter (with error bit) if a parameter is invalid.
*
+ * Errors (with error bit) from: f_memory_adjust().
+ * Errors (with error bit) from: f_memory_destroy().
+ *
* @see f_type_int128ss_adjust()
- * @see f_type_int128ss_resize()
+ * @see f_type_int128ss_decimate_by()
*/
#if !defined(_di_f_type_int128ss_adjust_) || !defined(_di_f_type_int128ss_decimate_by_)
extern f_status_t private_f_type_int128ss_adjust(const f_array_length_t length, f_int128ss_t *int128ss) f_gcc_attribute_visibility_internal;
* F_memory_not (with error bit) on out of memory.
* F_parameter (with error bit) if a parameter is invalid.
*
+ * Errors (with error bit) from: f_memory_delete().
+ * Errors (with error bit) from: f_memory_resize().
+ *
* @see f_type_int128ss_decrease_by()
* @see f_type_int128ss_increase()
* @see f_type_int128ss_increase_by()
#endif // !defined(_di_f_type_int128ss_decrease_by_) || !defined(_di_f_type_int128ss_increase_) || !defined(_di_f_type_int128ss_increase_by_) || !defined(_di_f_type_int128ss_resize_)
/**
+ * Private implementation for resizing the uint128s array.
+ *
+ * Intended to be shared to each of the different implementation variations.
+ *
+ * @param length
+ * The length to adjust to.
+ * @param uint128s
+ * The uint128s array to adjust.
+ *
+ * @return
+ * F_none on success.
+ * F_data_not on success, but there is no reason to increase size (used + 1 <= size).
+ *
+ * Errors (with error bit) from: f_memory_adjust().
+ *
+ * @see f_type_uint128s_adjust()
+ * @see f_type_uint128s_decimate_by()
+ */
+#if !defined(_di_f_type_uint128s_adjust_) || !defined(_di_f_type_uint128s_decimate_by_)
+ extern f_status_t private_f_type_uint128s_adjust(const f_array_length_t length, f_uint128s_t *uint128s) f_gcc_attribute_visibility_internal;
+#endif // !defined(_di_f_type_uint128s_adjust_) || !defined(_di_f_type_uint128s_decimate_by_)
+
+/**
+ * Private implementation for appending the uint128 array.
+ *
+ * Intended to be shared to each of the different implementation variations.
+ *
+ * @param source
+ * The source uint128s to append.
+ * @param destination
+ * The destination uint128s the source is appended onto.
+ *
+ * @return
+ * F_none on success.
+ *
+ * Errors (with error bit) from: f_memory_resize().
+ *
+ * @see f_type_uint128s_append()
+ * @see f_type_uint128ss_append()
+ */
+#if !defined(_di_f_type_uint128s_append_) || !defined(_di_f_type_uint128ss_append_)
+ extern f_status_t private_f_type_uint128s_append(const f_uint128s_t source, f_uint128s_t *destination) f_gcc_attribute_visibility_internal;
+#endif // !defined(_di_f_type_uint128s_append_) || !defined(_di_f_type_uint128ss_append_)
+
+/**
+ * Private implementation for resizing the uint128s array.
+ *
+ * Intended to be shared to each of the different implementation variations.
+ *
+ * @param length
+ * The length to adjust to.
+ * @param uint128s
+ * The uint128s array to adjust.
+ *
+ * @return
+ * F_none on success.
+ * F_data_not on success, but there is no reason to increase size (used + 1 <= size).
+ *
+ * Errors (with error bit) from: f_memory_resize().
+ *
+ * @see f_type_uint128s_resize()
+ * @see f_type_uint128s_append()
+ * @see f_type_uint128s_decimate_by()
+ * @see f_type_uint128ss_append()
+ */
+#if !defined(_di_f_type_uint128s_resize_) || !defined(_di_f_type_uint128s_append_) || !defined(_di_f_type_uint128s_decimate_by_) || !defined(_di_f_type_uint128ss_append_)
+ extern f_status_t private_f_type_uint128s_resize(const f_array_length_t length, f_uint128s_t *uint128s) f_gcc_attribute_visibility_internal;
+#endif // !defined(_di_f_type_uint128s_resize_) || !defined(_di_f_type_uint128s_append_) || !defined(_di_f_type_uint128s_decimate_by_) || !defined(_di_f_type_uint128ss_append_)
+
+/**
* Private implementation for resizing the uint128ss array.
*
* Intended to be shared to each of the different implementation variations.
* F_memory_not (with error bit) on out of memory.
* F_parameter (with error bit) if a parameter is invalid.
*
+ * Errors (with error bit) from: f_memory_adjust().
+ * Errors (with error bit) from: f_memory_destroy().
+ *
* @see f_type_uint128ss_adjust()
* @see f_type_uint128ss_decimate_by()
*/
* F_memory_not (with error bit) on out of memory.
* F_parameter (with error bit) if a parameter is invalid.
*
+ * Errors (with error bit) from: f_memory_delete().
+ * Errors (with error bit) from: f_memory_resize().
+ *
* @see f_type_uint128ss_decrease_by()
* @see f_type_uint128ss_increase()
* @see f_type_uint128ss_increase_by()
#ifdef __cplusplus
extern "C" {
#endif
+#ifndef _di_f_type_cells_adjust_
+ f_status_t f_type_cells_adjust(const f_array_length_t length, f_cells_t *cells) {
+ #ifndef _di_level_0_parameter_checking_
+ if (!cells) return F_status_set_error(F_parameter);
+ #endif // _di_level_0_parameter_checking_
+
+ return private_f_type_cells_adjust(length, cells);
+ }
+#endif // _di_f_type_cells_adjust_
+
+#ifndef _di_f_type_cells_append_
+ f_status_t f_type_cells_append(const f_cells_t source, f_cells_t *destination) {
+ #ifndef _di_level_0_parameter_checking_
+ if (!destination) return F_status_set_error(F_parameter);
+ #endif // _di_level_0_parameter_checking_
+
+ return private_f_type_cells_append(source, destination);
+ }
+#endif // _di_f_type_cells_append_
+
+#ifndef _di_f_type_cells_decimate_by_
+ f_status_t f_type_cells_decimate_by(const f_array_length_t amount, f_cells_t *cells) {
+ #ifndef _di_level_0_parameter_checking_
+ if (!amount) return F_status_set_error(F_parameter);
+ if (!cells) return F_status_set_error(F_parameter);
+ #endif // _di_level_0_parameter_checking_
+
+ if (cells->size - amount > 0) {
+ return private_f_type_cells_adjust(cells->size - amount, cells);
+ }
+
+ return private_f_type_cells_adjust(0, cells);
+ }
+#endif // _di_f_type_cells_decimate_by_
+
+#ifndef _di_f_type_cells_decrease_by_
+ f_status_t f_type_cells_decrease_by(const f_array_length_t amount, f_cells_t *cells) {
+ #ifndef _di_level_0_parameter_checking_
+ if (!amount) return F_status_set_error(F_parameter);
+ if (!cells) return F_status_set_error(F_parameter);
+ #endif // _di_level_0_parameter_checking_
+
+ if (cells->size - amount > 0) {
+ return private_f_type_cells_resize(cells->size - amount, cells);
+ }
+
+ return private_f_type_cells_resize(0, cells);
+ }
+#endif // _di_f_type_cells_decrease_by_
+
+#ifndef _di_f_type_cells_increase_
+ f_status_t f_type_cells_increase(f_cells_t *cells) {
+ #ifndef _di_level_0_parameter_checking_
+ if (!cells) return F_status_set_error(F_parameter);
+ #endif // _di_level_0_parameter_checking_
+
+ if (cells->used + 1 > cells->size) {
+ f_array_length_t size = cells->used + f_memory_default_allocation_step;
+
+ if (size > f_array_length_t_size) {
+ if (cells->used + 1 > f_array_length_t_size) {
+ return F_status_set_error(F_array_too_large);
+ }
+
+ size = f_array_length_t_size;
+ }
+
+ return private_f_type_cells_resize(size, cells);
+ }
+
+ return F_data_not;
+ }
+#endif // _di_f_type_cells_increase_
+
+#ifndef _di_f_type_cells_increase_by_
+ f_status_t f_type_cells_increase_by(const f_array_length_t amount, f_cells_t *cells) {
+ #ifndef _di_level_0_parameter_checking_
+ if (!amount) return F_status_set_error(F_parameter);
+ if (!cells) return F_status_set_error(F_parameter);
+ #endif // _di_level_0_parameter_checking_
+
+ if (cells->used + amount > cells->size) {
+ if (cells->used + amount > f_array_length_t_size) {
+ return F_status_set_error(F_array_too_large);
+ }
+
+ return private_f_type_cells_resize(cells->used + amount, cells);
+ }
+
+ return F_data_not;
+ }
+#endif // _di_f_type_cells_increase_by_
+
+#ifndef _di_f_type_cells_resize_
+ f_status_t f_type_cells_resize(const f_array_length_t length, f_cells_t *cells) {
+ #ifndef _di_level_0_parameter_checking_
+ if (!cells) return F_status_set_error(F_parameter);
+ #endif // _di_level_0_parameter_checking_
+
+ return private_f_type_cells_resize(length, cells);
+ }
+#endif // _di_f_type_cells_resize_
#ifndef _di_f_type_cellss_adjust_
f_status_t f_type_cellss_adjust(const f_array_length_t length, f_cellss_t *cellss) {
}
#endif // _di_f_type_cellss_adjust_
+#ifndef _di_f_type_cellss_append_
+ f_status_t f_type_cellss_append(const f_cellss_t source, f_cellss_t *destination) {
+ #ifndef _di_level_0_parameter_checking_
+ if (!destination) return F_status_set_error(F_parameter);
+ #endif // _di_level_0_parameter_checking_
+
+ f_status_t status = F_none;
+
+ if (destination->used + source.used > destination->size) {
+ status = private_f_type_cellss_resize(destination->used + source.used, destination);
+ if (F_status_is_error(status)) return status;
+ }
+
+ for (f_array_length_t i = 0; i < source.used; ++i, ++destination->used) {
+ status = private_f_type_cells_append(source.array[i], &destination->array[destination->used]);
+ if (F_status_is_error(status)) return status;
+ } // for
+
+ return F_none;
+ }
+#endif // _di_f_type_cellss_append_
+
#ifndef _di_f_type_cellss_decimate_by_
f_status_t f_type_cellss_decimate_by(const f_array_length_t amount, f_cellss_t *cellss) {
#ifndef _di_level_0_parameter_checking_
}
#endif // _di_f_type_cellss_resize_
-#ifndef _di_f_type_array_lengthssss_adjust_
- f_status_t f_type_array_lengthssss_adjust(const f_array_length_t length, f_array_lengthss_t *array_lengthss) {
+#ifndef _di_f_type_array_lengths_adjust_
+ f_status_t f_type_array_lengths_adjust(const f_array_length_t length, f_array_lengths_t *lengths) {
+ #ifndef _di_level_0_parameter_checking_
+ if (!lengths) return F_status_set_error(F_parameter);
+ #endif // _di_level_0_parameter_checking_
+
+ return private_f_type_array_lengths_adjust(length, lengths);
+ }
+#endif // _di_f_type_array_lengths_adjust_
+
+#ifndef _di_f_type_array_lengths_append_
+ f_status_t f_type_array_lengths_append(const f_array_lengths_t source, f_array_lengths_t *destination) {
+ #ifndef _di_level_0_parameter_checking_
+ if (!destination) return F_status_set_error(F_parameter);
+ #endif // _di_level_0_parameter_checking_
+
+ return private_f_type_array_lengths_append(source, destination);
+ }
+#endif // _di_f_type_array_lengths_append_
+
+#ifndef _di_f_type_array_lengths_decimate_by_
+ f_status_t f_type_array_lengths_decimate_by(const f_array_length_t amount, f_array_lengths_t *lengths) {
+ #ifndef _di_level_0_parameter_checking_
+ if (!amount) return F_status_set_error(F_parameter);
+ if (!lengths) return F_status_set_error(F_parameter);
+ #endif // _di_level_0_parameter_checking_
+
+ if (lengths->size - amount > 0) {
+ return private_f_type_array_lengths_adjust(lengths->size - amount, lengths);
+ }
+
+ return private_f_type_array_lengths_adjust(0, lengths);
+ }
+#endif // _di_f_type_array_lengths_decimate_by_
+
+#ifndef _di_f_type_array_lengths_decrease_by_
+ f_status_t f_type_array_lengths_decrease_by(const f_array_length_t amount, f_array_lengths_t *lengths) {
+ #ifndef _di_level_0_parameter_checking_
+ if (!amount) return F_status_set_error(F_parameter);
+ if (!lengths) return F_status_set_error(F_parameter);
+ #endif // _di_level_0_parameter_checking_
+
+ if (lengths->size - amount > 0) {
+ return private_f_type_array_lengths_resize(lengths->size - amount, lengths);
+ }
+
+ return private_f_type_array_lengths_resize(0, lengths);
+ }
+#endif // _di_f_type_array_lengths_decrease_by_
+
+#ifndef _di_f_type_array_lengths_increase_
+ f_status_t f_type_array_lengths_increase(f_array_lengths_t *lengths) {
+ #ifndef _di_level_0_parameter_checking_
+ if (!lengths) return F_status_set_error(F_parameter);
+ #endif // _di_level_0_parameter_checking_
+
+ if (lengths->used + 1 > lengths->size) {
+ f_array_length_t size = lengths->used + f_memory_default_allocation_step;
+
+ if (size > f_array_length_t_size) {
+ if (lengths->used + 1 > f_array_length_t_size) {
+ return F_status_set_error(F_array_too_large);
+ }
+
+ size = f_array_length_t_size;
+ }
+
+ return private_f_type_array_lengths_resize(size, lengths);
+ }
+
+ return F_data_not;
+ }
+#endif // _di_f_type_array_lengths_increase_
+
+#ifndef _di_f_type_array_lengths_increase_by_
+ f_status_t f_type_array_lengths_increase_by(const f_array_length_t amount, f_array_lengths_t *lengths) {
+ #ifndef _di_level_0_parameter_checking_
+ if (!amount) return F_status_set_error(F_parameter);
+ if (!lengths) return F_status_set_error(F_parameter);
+ #endif // _di_level_0_parameter_checking_
+
+ if (lengths->used + amount > lengths->size) {
+ if (lengths->used + amount > f_array_length_t_size) {
+ return F_status_set_error(F_array_too_large);
+ }
+
+ return private_f_type_array_lengths_resize(lengths->used + amount, lengths);
+ }
+
+ return F_data_not;
+ }
+#endif // _di_f_type_array_lengths_increase_by_
+
+#ifndef _di_f_type_array_lengths_resize_
+ f_status_t f_type_array_lengths_resize(const f_array_length_t length, f_array_lengths_t *lengths) {
+ #ifndef _di_level_0_parameter_checking_
+ if (!lengths) return F_status_set_error(F_parameter);
+ #endif // _di_level_0_parameter_checking_
+
+ return private_f_type_array_lengths_resize(length, lengths);
+ }
+#endif // _di_f_type_array_lengths_resize_
+
+#ifndef _di_f_type_array_lengthss_adjust_
+ f_status_t f_type_array_lengthss_adjust(const f_array_length_t length, f_array_lengthss_t *lengthss) {
#ifndef _di_level_0_parameter_checking_
- if (!array_lengthss) return F_status_set_error(F_parameter);
+ if (!lengthss) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
- return private_f_type_array_lengthss_adjust(length, array_lengthss);
+ return private_f_type_array_lengthss_adjust(length, lengthss);
}
#endif // _di_f_type_array_lengthss_adjust_
+#ifndef _di_f_type_array_lengthss_append_
+ f_status_t f_type_array_lengthss_append(const f_array_lengthss_t source, f_array_lengthss_t *destination) {
+ #ifndef _di_level_0_parameter_checking_
+ if (!destination) return F_status_set_error(F_parameter);
+ #endif // _di_level_0_parameter_checking_
+
+ f_status_t status = F_none;
+
+ if (destination->used + source.used > destination->size) {
+ status = private_f_type_array_lengthss_resize(destination->used + source.used, destination);
+ if (F_status_is_error(status)) return status;
+ }
+
+ for (f_array_length_t i = 0; i < source.used; ++i, ++destination->used) {
+ status = private_f_type_array_lengths_append(source.array[i], &destination->array[destination->used]);
+ if (F_status_is_error(status)) return status;
+ } // for
+
+ return F_none;
+ }
+#endif // _di_f_type_array_lengthss_append_
+
#ifndef _di_f_type_array_lengthss_decimate_by_
- f_status_t f_type_array_lengthss_decimate_by(const f_array_length_t amount, f_array_lengthss_t *array_lengthss) {
+ f_status_t f_type_array_lengthss_decimate_by(const f_array_length_t amount, f_array_lengthss_t *lengthss) {
#ifndef _di_level_0_parameter_checking_
if (!amount) return F_status_set_error(F_parameter);
- if (!array_lengthss) return F_status_set_error(F_parameter);
+ if (!lengthss) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
- if (array_lengthss->size - amount > 0) {
- return private_f_type_array_lengthss_adjust(array_lengthss->size - amount, array_lengthss);
+ if (lengthss->size - amount > 0) {
+ return private_f_type_array_lengthss_adjust(lengthss->size - amount, lengthss);
}
- return private_f_type_array_lengthss_adjust(0, array_lengthss);
+ return private_f_type_array_lengthss_adjust(0, lengthss);
}
#endif // _di_f_type_array_lengthss_decimate_by_
#ifndef _di_f_type_array_lengthss_decrease_by_
- f_status_t f_type_array_lengthss_decrease_by(const f_array_length_t amount, f_array_lengthss_t *array_lengthss) {
+ f_status_t f_type_array_lengthss_decrease_by(const f_array_length_t amount, f_array_lengthss_t *lengthss) {
#ifndef _di_level_0_parameter_checking_
if (!amount) return F_status_set_error(F_parameter);
- if (!array_lengthss) return F_status_set_error(F_parameter);
+ if (!lengthss) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
- if (array_lengthss->size - amount > 0) {
- return private_f_type_array_lengthss_resize(array_lengthss->size - amount, array_lengthss);
+ if (lengthss->size - amount > 0) {
+ return private_f_type_array_lengthss_resize(lengthss->size - amount, lengthss);
}
- return private_f_type_array_lengthss_resize(0, array_lengthss);
+ return private_f_type_array_lengthss_resize(0, lengthss);
}
#endif // _di_f_type_array_lengthss_decrease_by_
#ifndef _di_f_type_array_lengthss_increase_
- f_status_t f_type_array_lengthss_increase(f_array_lengthss_t *array_lengthss) {
+ f_status_t f_type_array_lengthss_increase(f_array_lengthss_t *lengthss) {
#ifndef _di_level_0_parameter_checking_
- if (!array_lengthss) return F_status_set_error(F_parameter);
+ if (!lengthss) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
- if (array_lengthss->used + 1 > array_lengthss->size) {
- f_array_length_t size = array_lengthss->used + f_memory_default_allocation_step;
+ if (lengthss->used + 1 > lengthss->size) {
+ f_array_length_t size = lengthss->used + f_memory_default_allocation_step;
if (size > f_array_length_t_size) {
- if (array_lengthss->used + 1 > f_array_length_t_size) {
+ if (lengthss->used + 1 > f_array_length_t_size) {
return F_status_set_error(F_array_too_large);
}
size = f_array_length_t_size;
}
- return private_f_type_array_lengthss_resize(size, array_lengthss);
+ return private_f_type_array_lengthss_resize(size, lengthss);
}
return F_data_not;
#endif // _di_f_type_array_lengthss_increase_
#ifndef _di_f_type_array_lengthss_increase_by_
- f_status_t f_type_array_lengthss_increase_by(const f_array_length_t amount, f_array_lengthss_t *array_lengthss) {
+ f_status_t f_type_array_lengthss_increase_by(const f_array_length_t amount, f_array_lengthss_t *lengthss) {
#ifndef _di_level_0_parameter_checking_
if (!amount) return F_status_set_error(F_parameter);
- if (!array_lengthss) return F_status_set_error(F_parameter);
+ if (!lengthss) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
- if (array_lengthss->used + amount > array_lengthss->size) {
- if (array_lengthss->used + amount > f_array_length_t_size) {
+ if (lengthss->used + amount > lengthss->size) {
+ if (lengthss->used + amount > f_array_length_t_size) {
return F_status_set_error(F_array_too_large);
}
- return private_f_type_array_lengthss_resize(array_lengthss->used + amount, array_lengthss);
+ return private_f_type_array_lengthss_resize(lengthss->used + amount, lengthss);
}
return F_data_not;
#endif // _di_f_type_array_lengthss_increase_by_
#ifndef _di_f_type_array_lengthss_resize_
- f_status_t f_type_array_lengthss_resize(const f_array_length_t length, f_array_lengthss_t *array_lengthss) {
+ f_status_t f_type_array_lengthss_resize(const f_array_length_t length, f_array_lengthss_t *lengthss) {
#ifndef _di_level_0_parameter_checking_
- if (!array_lengthss) return F_status_set_error(F_parameter);
+ if (!lengthss) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
- return private_f_type_array_lengthss_resize(length, array_lengthss);
+ return private_f_type_array_lengthss_resize(length, lengthss);
}
#endif // _di_f_type_array_lengthss_resize_
+#ifndef _di_f_type_int8s_adjust_
+ f_status_t f_type_int8s_adjust(const f_array_length_t length, f_int8s_t *int8s) {
+ #ifndef _di_level_0_parameter_checking_
+ if (!int8s) return F_status_set_error(F_parameter);
+ #endif // _di_level_0_parameter_checking_
+
+ return private_f_type_int8s_adjust(length, int8s);
+ }
+#endif // _di_f_type_int8s_adjust_
+
+#ifndef _di_f_type_int8s_append_
+ f_status_t f_type_int8s_append(const f_int8s_t source, f_int8s_t *destination) {
+ #ifndef _di_level_0_parameter_checking_
+ if (!destination) return F_status_set_error(F_parameter);
+ #endif // _di_level_0_parameter_checking_
+
+ return private_f_type_int8s_append(source, destination);
+ }
+#endif // _di_f_type_int8s_append_
+
+#ifndef _di_f_type_int8s_decimate_by_
+ f_status_t f_type_int8s_decimate_by(const f_array_length_t amount, f_int8s_t *int8s) {
+ #ifndef _di_level_0_parameter_checking_
+ if (!amount) return F_status_set_error(F_parameter);
+ if (!int8s) return F_status_set_error(F_parameter);
+ #endif // _di_level_0_parameter_checking_
+
+ if (int8s->size - amount > 0) {
+ return private_f_type_int8s_adjust(int8s->size - amount, int8s);
+ }
+
+ return private_f_type_int8s_adjust(0, int8s);
+ }
+#endif // _di_f_type_int8s_decimate_by_
+
+#ifndef _di_f_type_int8s_decrease_by_
+ f_status_t f_type_int8s_decrease_by(const f_array_length_t amount, f_int8s_t *int8s) {
+ #ifndef _di_level_0_parameter_checking_
+ if (!amount) return F_status_set_error(F_parameter);
+ if (!int8s) return F_status_set_error(F_parameter);
+ #endif // _di_level_0_parameter_checking_
+
+ if (int8s->size - amount > 0) {
+ return private_f_type_int8s_resize(int8s->size - amount, int8s);
+ }
+
+ return private_f_type_int8s_resize(0, int8s);
+ }
+#endif // _di_f_type_int8s_decrease_by_
+
+#ifndef _di_f_type_int8s_increase_
+ f_status_t f_type_int8s_increase(f_int8s_t *int8s) {
+ #ifndef _di_level_0_parameter_checking_
+ if (!int8s) return F_status_set_error(F_parameter);
+ #endif // _di_level_0_parameter_checking_
+
+ if (int8s->used + 1 > int8s->size) {
+ f_array_length_t size = int8s->used + f_memory_default_allocation_step;
+
+ if (size > f_array_length_t_size) {
+ if (int8s->used + 1 > f_array_length_t_size) {
+ return F_status_set_error(F_array_too_large);
+ }
+
+ size = f_array_length_t_size;
+ }
+
+ return private_f_type_int8s_resize(size, int8s);
+ }
+
+ return F_data_not;
+ }
+#endif // _di_f_type_int8s_increase_
+
+#ifndef _di_f_type_int8s_increase_by_
+ f_status_t f_type_int8s_increase_by(const f_array_length_t amount, f_int8s_t *int8s) {
+ #ifndef _di_level_0_parameter_checking_
+ if (!amount) return F_status_set_error(F_parameter);
+ if (!int8s) return F_status_set_error(F_parameter);
+ #endif // _di_level_0_parameter_checking_
+
+ if (int8s->used + amount > int8s->size) {
+ if (int8s->used + amount > f_array_length_t_size) {
+ return F_status_set_error(F_array_too_large);
+ }
+
+ return private_f_type_int8s_resize(int8s->used + amount, int8s);
+ }
+
+ return F_data_not;
+ }
+#endif // _di_f_type_int8s_increase_by_
+
+#ifndef _di_f_type_int8s_resize_
+ f_status_t f_type_int8s_resize(const f_array_length_t length, f_int8s_t *int8s) {
+ #ifndef _di_level_0_parameter_checking_
+ if (!int8s) return F_status_set_error(F_parameter);
+ #endif // _di_level_0_parameter_checking_
+
+ return private_f_type_int8s_resize(length, int8s);
+ }
+#endif // _di_f_type_int8s_resize_
+
#ifndef _di_f_type_int8ss_adjust_
f_status_t f_type_int8ss_adjust(const f_array_length_t length, f_int8ss_t *int8ss) {
#ifndef _di_level_0_parameter_checking_
}
#endif // _di_f_type_int8ss_adjust_
+#ifndef _di_f_type_int8ss_append_
+ f_status_t f_type_int8ss_append(const f_int8ss_t source, f_int8ss_t *destination) {
+ #ifndef _di_level_0_parameter_checking_
+ if (!destination) return F_status_set_error(F_parameter);
+ #endif // _di_level_0_parameter_checking_
+
+ f_status_t status = F_none;
+
+ if (destination->used + source.used > destination->size) {
+ status = private_f_type_int8ss_resize(destination->used + source.used, destination);
+ if (F_status_is_error(status)) return status;
+ }
+
+ for (f_array_length_t i = 0; i < source.used; ++i, ++destination->used) {
+ status = private_f_type_int8s_append(source.array[i], &destination->array[destination->used]);
+ if (F_status_is_error(status)) return status;
+ } // for
+
+ return F_none;
+ }
+#endif // _di_f_type_int8ss_append_
+
#ifndef _di_f_type_int8ss_decimate_by_
f_status_t f_type_int8ss_decimate_by(const f_array_length_t amount, f_int8ss_t *int8ss) {
#ifndef _di_level_0_parameter_checking_
}
#endif // _di_f_type_int8ss_resize_
-#ifndef _di_f_type_uint8ss_adjust_
- f_status_t f_type_uint8ss_adjust(const f_array_length_t length, f_uint8ss_t *uint8ss) {
+#ifndef _di_f_type_uint8s_adjust_
+ f_status_t f_type_uint8s_adjust(const f_array_length_t length, f_uint8s_t *uint8s) {
#ifndef _di_level_0_parameter_checking_
- if (!uint8ss) return F_status_set_error(F_parameter);
+ if (!uint8s) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
- return private_f_type_uint8ss_adjust(length, uint8ss);
+ return private_f_type_uint8s_adjust(length, uint8s);
}
-#endif // _di_f_type_uint8ss_adjust_
+#endif // _di_f_type_uint8s_adjust_
-#ifndef _di_f_type_uint8ss_decimate_by_
- f_status_t f_type_uint8ss_decimate_by(const f_array_length_t amount, f_uint8ss_t *uint8ss) {
+#ifndef _di_f_type_uint8s_append_
+ f_status_t f_type_uint8s_append(const f_uint8s_t source, f_uint8s_t *destination) {
+ #ifndef _di_level_0_parameter_checking_
+ if (!destination) return F_status_set_error(F_parameter);
+ #endif // _di_level_0_parameter_checking_
+
+ return private_f_type_uint8s_append(source, destination);
+ }
+#endif // _di_f_type_uint8s_append_
+
+#ifndef _di_f_type_uint8s_decimate_by_
+ f_status_t f_type_uint8s_decimate_by(const f_array_length_t amount, f_uint8s_t *uint8s) {
#ifndef _di_level_0_parameter_checking_
if (!amount) return F_status_set_error(F_parameter);
- if (!uint8ss) return F_status_set_error(F_parameter);
+ if (!uint8s) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
- if (uint8ss->size - amount > 0) {
- return private_f_type_uint8ss_adjust(uint8ss->size - amount, uint8ss);
+ if (uint8s->size - amount > 0) {
+ return private_f_type_uint8s_adjust(uint8s->size - amount, uint8s);
}
- return private_f_type_uint8ss_adjust(0, uint8ss);
+ return private_f_type_uint8s_adjust(0, uint8s);
}
-#endif // _di_f_type_uint8ss_decimate_by_
+#endif // _di_f_type_uint8s_decimate_by_
-#ifndef _di_f_type_uint8ss_decrease_by_
- f_status_t f_type_uint8ss_decrease_by(const f_array_length_t amount, f_uint8ss_t *uint8ss) {
+#ifndef _di_f_type_uint8s_decrease_by_
+ f_status_t f_type_uint8s_decrease_by(const f_array_length_t amount, f_uint8s_t *uint8s) {
#ifndef _di_level_0_parameter_checking_
if (!amount) return F_status_set_error(F_parameter);
- if (!uint8ss) return F_status_set_error(F_parameter);
+ if (!uint8s) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
- if (uint8ss->size - amount > 0) {
- return private_f_type_uint8ss_resize(uint8ss->size - amount, uint8ss);
+ if (uint8s->size - amount > 0) {
+ return private_f_type_uint8s_resize(uint8s->size - amount, uint8s);
}
- return private_f_type_uint8ss_resize(0, uint8ss);
+ return private_f_type_uint8s_resize(0, uint8s);
}
-#endif // _di_f_type_uint8ss_decrease_by_
+#endif // _di_f_type_uint8s_decrease_by_
-#ifndef _di_f_type_uint8ss_increase_
- f_status_t f_type_uint8ss_increase(f_uint8ss_t *uint8ss) {
+#ifndef _di_f_type_uint8s_increase_
+ f_status_t f_type_uint8s_increase(f_uint8s_t *uint8s) {
#ifndef _di_level_0_parameter_checking_
- if (!uint8ss) return F_status_set_error(F_parameter);
+ if (!uint8s) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
- if (uint8ss->used + 1 > uint8ss->size) {
- f_array_length_t size = uint8ss->used + f_memory_default_allocation_step;
+ if (uint8s->used + 1 > uint8s->size) {
+ f_array_length_t size = uint8s->used + f_memory_default_allocation_step;
if (size > f_array_length_t_size) {
- if (uint8ss->used + 1 > f_array_length_t_size) {
+ if (uint8s->used + 1 > f_array_length_t_size) {
return F_status_set_error(F_array_too_large);
}
size = f_array_length_t_size;
}
- return private_f_type_uint8ss_resize(size, uint8ss);
+ return private_f_type_uint8s_resize(size, uint8s);
}
return F_data_not;
}
-#endif // _di_f_type_uint8ss_increase_
+#endif // _di_f_type_uint8s_increase_
-#ifndef _di_f_type_uint8ss_increase_by_
- f_status_t f_type_uint8ss_increase_by(const f_array_length_t amount, f_uint8ss_t *uint8ss) {
+#ifndef _di_f_type_uint8s_increase_by_
+ f_status_t f_type_uint8s_increase_by(const f_array_length_t amount, f_uint8s_t *uint8s) {
#ifndef _di_level_0_parameter_checking_
if (!amount) return F_status_set_error(F_parameter);
- if (!uint8ss) return F_status_set_error(F_parameter);
+ if (!uint8s) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
- if (uint8ss->used + amount > uint8ss->size) {
- if (uint8ss->used + amount > f_array_length_t_size) {
+ if (uint8s->used + amount > uint8s->size) {
+ if (uint8s->used + amount > f_array_length_t_size) {
return F_status_set_error(F_array_too_large);
}
- return private_f_type_uint8ss_resize(uint8ss->used + amount, uint8ss);
+ return private_f_type_uint8s_resize(uint8s->used + amount, uint8s);
}
return F_data_not;
}
-#endif // _di_f_type_uint8ss_increase_by_
+#endif // _di_f_type_uint8s_increase_by_
-#ifndef _di_f_type_uint8ss_resize_
- f_status_t f_type_uint8ss_resize(const f_array_length_t length, f_uint8ss_t *uint8ss) {
+#ifndef _di_f_type_uint8s_resize_
+ f_status_t f_type_uint8s_resize(const f_array_length_t length, f_uint8s_t *uint8s) {
#ifndef _di_level_0_parameter_checking_
- if (!uint8ss) return F_status_set_error(F_parameter);
+ if (!uint8s) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
- return private_f_type_uint8ss_resize(length, uint8ss);
+ return private_f_type_uint8s_resize(length, uint8s);
}
-#endif // _di_f_type_uint8ss_resize_
+#endif // _di_f_type_uint8s_resize_
-#ifndef _di_f_type_int16ss_adjust_
- f_status_t f_type_int16ss_adjust(const f_array_length_t length, f_int16ss_t *int16ss) {
+#ifndef _di_f_type_uint8ss_adjust_
+ f_status_t f_type_uint8ss_adjust(const f_array_length_t length, f_uint8ss_t *uint8ss) {
#ifndef _di_level_0_parameter_checking_
- if (!int16ss) return F_status_set_error(F_parameter);
+ if (!uint8ss) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
- return private_f_type_int16ss_adjust(length, int16ss);
+ return private_f_type_uint8ss_adjust(length, uint8ss);
}
-#endif // _di_f_type_int16ss_adjust_
+#endif // _di_f_type_uint8ss_adjust_
+
+#ifndef _di_f_type_uint8ss_append_
+ f_status_t f_type_uint8ss_append(const f_uint8ss_t source, f_uint8ss_t *destination) {
+ #ifndef _di_level_0_parameter_checking_
+ if (!destination) return F_status_set_error(F_parameter);
+ #endif // _di_level_0_parameter_checking_
+
+ f_status_t status = F_none;
+
+ if (destination->used + source.used > destination->size) {
+ status = private_f_type_uint8ss_resize(destination->used + source.used, destination);
+ if (F_status_is_error(status)) return status;
+ }
+
+ for (f_array_length_t i = 0; i < source.used; ++i, ++destination->used) {
+ status = private_f_type_uint8s_append(source.array[i], &destination->array[destination->used]);
+ if (F_status_is_error(status)) return status;
+ } // for
+
+ return F_none;
+ }
+#endif // _di_f_type_uint8ss_append_
+
+#ifndef _di_f_type_uint8ss_decimate_by_
+ f_status_t f_type_uint8ss_decimate_by(const f_array_length_t amount, f_uint8ss_t *uint8ss) {
+ #ifndef _di_level_0_parameter_checking_
+ if (!amount) return F_status_set_error(F_parameter);
+ if (!uint8ss) return F_status_set_error(F_parameter);
+ #endif // _di_level_0_parameter_checking_
+
+ if (uint8ss->size - amount > 0) {
+ return private_f_type_uint8ss_adjust(uint8ss->size - amount, uint8ss);
+ }
+
+ return private_f_type_uint8ss_adjust(0, uint8ss);
+ }
+#endif // _di_f_type_uint8ss_decimate_by_
+
+#ifndef _di_f_type_uint8ss_decrease_by_
+ f_status_t f_type_uint8ss_decrease_by(const f_array_length_t amount, f_uint8ss_t *uint8ss) {
+ #ifndef _di_level_0_parameter_checking_
+ if (!amount) return F_status_set_error(F_parameter);
+ if (!uint8ss) return F_status_set_error(F_parameter);
+ #endif // _di_level_0_parameter_checking_
+
+ if (uint8ss->size - amount > 0) {
+ return private_f_type_uint8ss_resize(uint8ss->size - amount, uint8ss);
+ }
+
+ return private_f_type_uint8ss_resize(0, uint8ss);
+ }
+#endif // _di_f_type_uint8ss_decrease_by_
+
+#ifndef _di_f_type_uint8ss_increase_
+ f_status_t f_type_uint8ss_increase(f_uint8ss_t *uint8ss) {
+ #ifndef _di_level_0_parameter_checking_
+ if (!uint8ss) return F_status_set_error(F_parameter);
+ #endif // _di_level_0_parameter_checking_
+
+ if (uint8ss->used + 1 > uint8ss->size) {
+ f_array_length_t size = uint8ss->used + f_memory_default_allocation_step;
+
+ if (size > f_array_length_t_size) {
+ if (uint8ss->used + 1 > f_array_length_t_size) {
+ return F_status_set_error(F_array_too_large);
+ }
+
+ size = f_array_length_t_size;
+ }
+
+ return private_f_type_uint8ss_resize(size, uint8ss);
+ }
+
+ return F_data_not;
+ }
+#endif // _di_f_type_uint8ss_increase_
+
+#ifndef _di_f_type_uint8ss_increase_by_
+ f_status_t f_type_uint8ss_increase_by(const f_array_length_t amount, f_uint8ss_t *uint8ss) {
+ #ifndef _di_level_0_parameter_checking_
+ if (!amount) return F_status_set_error(F_parameter);
+ if (!uint8ss) return F_status_set_error(F_parameter);
+ #endif // _di_level_0_parameter_checking_
+
+ if (uint8ss->used + amount > uint8ss->size) {
+ if (uint8ss->used + amount > f_array_length_t_size) {
+ return F_status_set_error(F_array_too_large);
+ }
+
+ return private_f_type_uint8ss_resize(uint8ss->used + amount, uint8ss);
+ }
+
+ return F_data_not;
+ }
+#endif // _di_f_type_uint8ss_increase_by_
+
+#ifndef _di_f_type_uint8ss_resize_
+ f_status_t f_type_uint8ss_resize(const f_array_length_t length, f_uint8ss_t *uint8ss) {
+ #ifndef _di_level_0_parameter_checking_
+ if (!uint8ss) return F_status_set_error(F_parameter);
+ #endif // _di_level_0_parameter_checking_
+
+ return private_f_type_uint8ss_resize(length, uint8ss);
+ }
+#endif // _di_f_type_uint8ss_resize_
+
+#ifndef _di_f_type_int16s_adjust_
+ f_status_t f_type_int16s_adjust(const f_array_length_t length, f_int16s_t *int16s) {
+ #ifndef _di_level_0_parameter_checking_
+ if (!int16s) return F_status_set_error(F_parameter);
+ #endif // _di_level_0_parameter_checking_
+
+ return private_f_type_int16s_adjust(length, int16s);
+ }
+#endif // _di_f_type_int16s_adjust_
+
+#ifndef _di_f_type_int16s_append_
+ f_status_t f_type_int16s_append(const f_int16s_t source, f_int16s_t *destination) {
+ #ifndef _di_level_0_parameter_checking_
+ if (!destination) return F_status_set_error(F_parameter);
+ #endif // _di_level_0_parameter_checking_
+
+ return private_f_type_int16s_append(source, destination);
+ }
+#endif // _di_f_type_int16s_append_
+
+#ifndef _di_f_type_int16s_decimate_by_
+ f_status_t f_type_int16s_decimate_by(const f_array_length_t amount, f_int16s_t *int16s) {
+ #ifndef _di_level_0_parameter_checking_
+ if (!amount) return F_status_set_error(F_parameter);
+ if (!int16s) return F_status_set_error(F_parameter);
+ #endif // _di_level_0_parameter_checking_
+
+ if (int16s->size - amount > 0) {
+ return private_f_type_int16s_adjust(int16s->size - amount, int16s);
+ }
+
+ return private_f_type_int16s_adjust(0, int16s);
+ }
+#endif // _di_f_type_int16s_decimate_by_
+
+#ifndef _di_f_type_int16s_decrease_by_
+ f_status_t f_type_int16s_decrease_by(const f_array_length_t amount, f_int16s_t *int16s) {
+ #ifndef _di_level_0_parameter_checking_
+ if (!amount) return F_status_set_error(F_parameter);
+ if (!int16s) return F_status_set_error(F_parameter);
+ #endif // _di_level_0_parameter_checking_
+
+ if (int16s->size - amount > 0) {
+ return private_f_type_int16s_resize(int16s->size - amount, int16s);
+ }
+
+ return private_f_type_int16s_resize(0, int16s);
+ }
+#endif // _di_f_type_int16s_decrease_by_
+
+#ifndef _di_f_type_int16s_increase_
+ f_status_t f_type_int16s_increase(f_int16s_t *int16s) {
+ #ifndef _di_level_0_parameter_checking_
+ if (!int16s) return F_status_set_error(F_parameter);
+ #endif // _di_level_0_parameter_checking_
+
+ if (int16s->used + 1 > int16s->size) {
+ f_array_length_t size = int16s->used + f_memory_default_allocation_step;
+
+ if (size > f_array_length_t_size) {
+ if (int16s->used + 1 > f_array_length_t_size) {
+ return F_status_set_error(F_array_too_large);
+ }
+
+ size = f_array_length_t_size;
+ }
+
+ return private_f_type_int16s_resize(size, int16s);
+ }
+
+ return F_data_not;
+ }
+#endif // _di_f_type_int16s_increase_
+
+#ifndef _di_f_type_int16s_increase_by_
+ f_status_t f_type_int16s_increase_by(const f_array_length_t amount, f_int16s_t *int16s) {
+ #ifndef _di_level_0_parameter_checking_
+ if (!amount) return F_status_set_error(F_parameter);
+ if (!int16s) return F_status_set_error(F_parameter);
+ #endif // _di_level_0_parameter_checking_
+
+ if (int16s->used + amount > int16s->size) {
+ if (int16s->used + amount > f_array_length_t_size) {
+ return F_status_set_error(F_array_too_large);
+ }
+
+ return private_f_type_int16s_resize(int16s->used + amount, int16s);
+ }
+
+ return F_data_not;
+ }
+#endif // _di_f_type_int16s_increase_by_
+
+#ifndef _di_f_type_int16s_resize_
+ f_status_t f_type_int16s_resize(const f_array_length_t length, f_int16s_t *int16s) {
+ #ifndef _di_level_0_parameter_checking_
+ if (!int16s) return F_status_set_error(F_parameter);
+ #endif // _di_level_0_parameter_checking_
+
+ return private_f_type_int16s_resize(length, int16s);
+ }
+#endif // _di_f_type_int16s_resize_
+
+#ifndef _di_f_type_int16ss_adjust_
+ f_status_t f_type_int16ss_adjust(const f_array_length_t length, f_int16ss_t *int16ss) {
+ #ifndef _di_level_0_parameter_checking_
+ if (!int16ss) return F_status_set_error(F_parameter);
+ #endif // _di_level_0_parameter_checking_
+
+ return private_f_type_int16ss_adjust(length, int16ss);
+ }
+#endif // _di_f_type_int16ss_adjust_
+
+#ifndef _di_f_type_int16ss_append_
+ f_status_t f_type_int16ss_append(const f_int16ss_t source, f_int16ss_t *destination) {
+ #ifndef _di_level_0_parameter_checking_
+ if (!destination) return F_status_set_error(F_parameter);
+ #endif // _di_level_0_parameter_checking_
+
+ f_status_t status = F_none;
+
+ if (destination->used + source.used > destination->size) {
+ status = private_f_type_int16ss_resize(destination->used + source.used, destination);
+ if (F_status_is_error(status)) return status;
+ }
+
+ for (f_array_length_t i = 0; i < source.used; ++i, ++destination->used) {
+ status = private_f_type_int16s_append(source.array[i], &destination->array[destination->used]);
+ if (F_status_is_error(status)) return status;
+ } // for
+
+ return F_none;
+ }
+#endif // _di_f_type_int16ss_append_
#ifndef _di_f_type_int16ss_decimate_by_
f_status_t f_type_int16ss_decimate_by(const f_array_length_t amount, f_int16ss_t *int16ss) {
}
#endif // _di_f_type_int16ss_resize_
+#ifndef _di_f_type_uint16s_adjust_
+ f_status_t f_type_uint16s_adjust(const f_array_length_t length, f_uint16s_t *uint16s) {
+ #ifndef _di_level_0_parameter_checking_
+ if (!uint16s) return F_status_set_error(F_parameter);
+ #endif // _di_level_0_parameter_checking_
+
+ return private_f_type_uint16s_adjust(length, uint16s);
+ }
+#endif // _di_f_type_uint16s_adjust_
+
+#ifndef _di_f_type_uint16s_append_
+ f_status_t f_type_uint16s_append(const f_uint16s_t source, f_uint16s_t *destination) {
+ #ifndef _di_level_0_parameter_checking_
+ if (!destination) return F_status_set_error(F_parameter);
+ #endif // _di_level_0_parameter_checking_
+
+ return private_f_type_uint16s_append(source, destination);
+ }
+#endif // _di_f_type_uint16s_append_
+
+#ifndef _di_f_type_uint16s_decimate_by_
+ f_status_t f_type_uint16s_decimate_by(const f_array_length_t amount, f_uint16s_t *uint16s) {
+ #ifndef _di_level_0_parameter_checking_
+ if (!amount) return F_status_set_error(F_parameter);
+ if (!uint16s) return F_status_set_error(F_parameter);
+ #endif // _di_level_0_parameter_checking_
+
+ if (uint16s->size - amount > 0) {
+ return private_f_type_uint16s_adjust(uint16s->size - amount, uint16s);
+ }
+
+ return private_f_type_uint16s_adjust(0, uint16s);
+ }
+#endif // _di_f_type_uint16s_decimate_by_
+
+#ifndef _di_f_type_uint16s_decrease_by_
+ f_status_t f_type_uint16s_decrease_by(const f_array_length_t amount, f_uint16s_t *uint16s) {
+ #ifndef _di_level_0_parameter_checking_
+ if (!amount) return F_status_set_error(F_parameter);
+ if (!uint16s) return F_status_set_error(F_parameter);
+ #endif // _di_level_0_parameter_checking_
+
+ if (uint16s->size - amount > 0) {
+ return private_f_type_uint16s_resize(uint16s->size - amount, uint16s);
+ }
+
+ return private_f_type_uint16s_resize(0, uint16s);
+ }
+#endif // _di_f_type_uint16s_decrease_by_
+
+#ifndef _di_f_type_uint16s_increase_
+ f_status_t f_type_uint16s_increase(f_uint16s_t *uint16s) {
+ #ifndef _di_level_0_parameter_checking_
+ if (!uint16s) return F_status_set_error(F_parameter);
+ #endif // _di_level_0_parameter_checking_
+
+ if (uint16s->used + 1 > uint16s->size) {
+ f_array_length_t size = uint16s->used + f_memory_default_allocation_step;
+
+ if (size > f_array_length_t_size) {
+ if (uint16s->used + 1 > f_array_length_t_size) {
+ return F_status_set_error(F_array_too_large);
+ }
+
+ size = f_array_length_t_size;
+ }
+
+ return private_f_type_uint16s_resize(size, uint16s);
+ }
+
+ return F_data_not;
+ }
+#endif // _di_f_type_uint16s_increase_
+
+#ifndef _di_f_type_uint16s_increase_by_
+ f_status_t f_type_uint16s_increase_by(const f_array_length_t amount, f_uint16s_t *uint16s) {
+ #ifndef _di_level_0_parameter_checking_
+ if (!amount) return F_status_set_error(F_parameter);
+ if (!uint16s) return F_status_set_error(F_parameter);
+ #endif // _di_level_0_parameter_checking_
+
+ if (uint16s->used + amount > uint16s->size) {
+ if (uint16s->used + amount > f_array_length_t_size) {
+ return F_status_set_error(F_array_too_large);
+ }
+
+ return private_f_type_uint16s_resize(uint16s->used + amount, uint16s);
+ }
+
+ return F_data_not;
+ }
+#endif // _di_f_type_uint16s_increase_by_
+
+#ifndef _di_f_type_uint16s_resize_
+ f_status_t f_type_uint16s_resize(const f_array_length_t length, f_uint16s_t *uint16s) {
+ #ifndef _di_level_0_parameter_checking_
+ if (!uint16s) return F_status_set_error(F_parameter);
+ #endif // _di_level_0_parameter_checking_
+
+ return private_f_type_uint16s_resize(length, uint16s);
+ }
+#endif // _di_f_type_uint16s_resize_
+
+#ifndef _di_f_type_uint16ss_adjust_
+ f_status_t f_type_uint16ss_adjust(const f_array_length_t length, f_uint16ss_t *uint16ss) {
+ #ifndef _di_level_0_parameter_checking_
+ if (!uint16ss) return F_status_set_error(F_parameter);
+ #endif // _di_level_0_parameter_checking_
+
+ return private_f_type_uint16ss_adjust(length, uint16ss);
+ }
+#endif // _di_f_type_uint16ss_adjust_
+
+#ifndef _di_f_type_uint16ss_append_
+ f_status_t f_type_uint16ss_append(const f_uint16ss_t source, f_uint16ss_t *destination) {
+ #ifndef _di_level_0_parameter_checking_
+ if (!destination) return F_status_set_error(F_parameter);
+ #endif // _di_level_0_parameter_checking_
+
+ f_status_t status = F_none;
+
+ if (destination->used + source.used > destination->size) {
+ status = private_f_type_uint16ss_resize(destination->used + source.used, destination);
+ if (F_status_is_error(status)) return status;
+ }
+
+ for (f_array_length_t i = 0; i < source.used; ++i, ++destination->used) {
+ status = private_f_type_uint16s_append(source.array[i], &destination->array[destination->used]);
+ if (F_status_is_error(status)) return status;
+ } // for
+
+ return F_none;
+ }
+#endif // _di_f_type_uint16ss_append_
+
#ifndef _di_f_type_uint16ss_decimate_by_
f_status_t f_type_uint16ss_decimate_by(const f_array_length_t amount, f_uint16ss_t *uint16ss) {
#ifndef _di_level_0_parameter_checking_
}
#endif // _di_f_type_uint16ss_resize_
+#ifndef _di_f_type_int32s_adjust_
+ f_status_t f_type_int32s_adjust(const f_array_length_t length, f_int32s_t *int32s) {
+ #ifndef _di_level_0_parameter_checking_
+ if (!int32s) return F_status_set_error(F_parameter);
+ #endif // _di_level_0_parameter_checking_
+
+ return private_f_type_int32s_adjust(length, int32s);
+ }
+#endif // _di_f_type_int32s_adjust_
+
+#ifndef _di_f_type_int32s_append_
+ f_status_t f_type_int32s_append(const f_int32s_t source, f_int32s_t *destination) {
+ #ifndef _di_level_0_parameter_checking_
+ if (!destination) return F_status_set_error(F_parameter);
+ #endif // _di_level_0_parameter_checking_
+
+ return private_f_type_int32s_append(source, destination);
+ }
+#endif // _di_f_type_int32s_append_
+
+#ifndef _di_f_type_int32s_decimate_by_
+ f_status_t f_type_int32s_decimate_by(const f_array_length_t amount, f_int32s_t *int32s) {
+ #ifndef _di_level_0_parameter_checking_
+ if (!amount) return F_status_set_error(F_parameter);
+ if (!int32s) return F_status_set_error(F_parameter);
+ #endif // _di_level_0_parameter_checking_
+
+ if (int32s->size - amount > 0) {
+ return private_f_type_int32s_adjust(int32s->size - amount, int32s);
+ }
+
+ return private_f_type_int32s_adjust(0, int32s);
+ }
+#endif // _di_f_type_int32s_decimate_by_
+
+#ifndef _di_f_type_int32s_decrease_by_
+ f_status_t f_type_int32s_decrease_by(const f_array_length_t amount, f_int32s_t *int32s) {
+ #ifndef _di_level_0_parameter_checking_
+ if (!amount) return F_status_set_error(F_parameter);
+ if (!int32s) return F_status_set_error(F_parameter);
+ #endif // _di_level_0_parameter_checking_
+
+ if (int32s->size - amount > 0) {
+ return private_f_type_int32s_resize(int32s->size - amount, int32s);
+ }
+
+ return private_f_type_int32s_resize(0, int32s);
+ }
+#endif // _di_f_type_int32s_decrease_by_
+
+#ifndef _di_f_type_int32s_increase_
+ f_status_t f_type_int32s_increase(f_int32s_t *int32s) {
+ #ifndef _di_level_0_parameter_checking_
+ if (!int32s) return F_status_set_error(F_parameter);
+ #endif // _di_level_0_parameter_checking_
+
+ if (int32s->used + 1 > int32s->size) {
+ f_array_length_t size = int32s->used + f_memory_default_allocation_step;
+
+ if (size > f_array_length_t_size) {
+ if (int32s->used + 1 > f_array_length_t_size) {
+ return F_status_set_error(F_array_too_large);
+ }
+
+ size = f_array_length_t_size;
+ }
+
+ return private_f_type_int32s_resize(size, int32s);
+ }
+
+ return F_data_not;
+ }
+#endif // _di_f_type_int32s_increase_
+
+#ifndef _di_f_type_int32s_increase_by_
+ f_status_t f_type_int32s_increase_by(const f_array_length_t amount, f_int32s_t *int32s) {
+ #ifndef _di_level_0_parameter_checking_
+ if (!amount) return F_status_set_error(F_parameter);
+ if (!int32s) return F_status_set_error(F_parameter);
+ #endif // _di_level_0_parameter_checking_
+
+ if (int32s->used + amount > int32s->size) {
+ if (int32s->used + amount > f_array_length_t_size) {
+ return F_status_set_error(F_array_too_large);
+ }
+
+ return private_f_type_int32s_resize(int32s->used + amount, int32s);
+ }
+
+ return F_data_not;
+ }
+#endif // _di_f_type_int32s_increase_by_
+
+#ifndef _di_f_type_int32s_resize_
+ f_status_t f_type_int32s_resize(const f_array_length_t length, f_int32s_t *int32s) {
+ #ifndef _di_level_0_parameter_checking_
+ if (!int32s) return F_status_set_error(F_parameter);
+ #endif // _di_level_0_parameter_checking_
+
+ return private_f_type_int32s_resize(length, int32s);
+ }
+#endif // _di_f_type_int32s_resize_
+
#ifndef _di_f_type_int32ss_adjust_
f_status_t f_type_int32ss_adjust(const f_array_length_t length, f_int32ss_t *int32ss) {
#ifndef _di_level_0_parameter_checking_
}
#endif // _di_f_type_int32ss_adjust_
+#ifndef _di_f_type_int32ss_append_
+ f_status_t f_type_int32ss_append(const f_int32ss_t source, f_int32ss_t *destination) {
+ #ifndef _di_level_0_parameter_checking_
+ if (!destination) return F_status_set_error(F_parameter);
+ #endif // _di_level_0_parameter_checking_
+
+ f_status_t status = F_none;
+
+ if (destination->used + source.used > destination->size) {
+ status = private_f_type_int32ss_resize(destination->used + source.used, destination);
+ if (F_status_is_error(status)) return status;
+ }
+
+ for (f_array_length_t i = 0; i < source.used; ++i, ++destination->used) {
+ status = private_f_type_int32s_append(source.array[i], &destination->array[destination->used]);
+ if (F_status_is_error(status)) return status;
+ } // for
+
+ return F_none;
+ }
+#endif // _di_f_type_int32ss_append_
+
#ifndef _di_f_type_int32ss_decimate_by_
f_status_t f_type_int32ss_decimate_by(const f_array_length_t amount, f_int32ss_t *int32ss) {
#ifndef _di_level_0_parameter_checking_
#ifndef _di_f_type_int32ss_resize_
f_status_t f_type_int32ss_resize(const f_array_length_t length, f_int32ss_t *int32ss) {
#ifndef _di_level_0_parameter_checking_
- if (!int32ss) return F_status_set_error(F_parameter);
+ if (!int32ss) return F_status_set_error(F_parameter);
+ #endif // _di_level_0_parameter_checking_
+
+ return private_f_type_int32ss_resize(length, int32ss);
+ }
+#endif // _di_f_type_int32ss_resize_
+
+#ifndef _di_f_type_uint32s_adjust_
+ f_status_t f_type_uint32s_adjust(const f_array_length_t length, f_uint32s_t *uint32s) {
+ #ifndef _di_level_0_parameter_checking_
+ if (!uint32s) return F_status_set_error(F_parameter);
+ #endif // _di_level_0_parameter_checking_
+
+ return private_f_type_uint32s_adjust(length, uint32s);
+ }
+#endif // _di_f_type_uint32s_adjust_
+
+#ifndef _di_f_type_uint32s_append_
+ f_status_t f_type_uint32s_append(const f_uint32s_t source, f_uint32s_t *destination) {
+ #ifndef _di_level_0_parameter_checking_
+ if (!destination) return F_status_set_error(F_parameter);
+ #endif // _di_level_0_parameter_checking_
+
+ return private_f_type_uint32s_append(source, destination);
+ }
+#endif // _di_f_type_uint32s_append_
+
+#ifndef _di_f_type_uint32s_decimate_by_
+ f_status_t f_type_uint32s_decimate_by(const f_array_length_t amount, f_uint32s_t *uint32s) {
+ #ifndef _di_level_0_parameter_checking_
+ if (!amount) return F_status_set_error(F_parameter);
+ if (!uint32s) return F_status_set_error(F_parameter);
+ #endif // _di_level_0_parameter_checking_
+
+ if (uint32s->size - amount > 0) {
+ return private_f_type_uint32s_adjust(uint32s->size - amount, uint32s);
+ }
+
+ return private_f_type_uint32s_adjust(0, uint32s);
+ }
+#endif // _di_f_type_uint32s_decimate_by_
+
+#ifndef _di_f_type_uint32s_decrease_by_
+ f_status_t f_type_uint32s_decrease_by(const f_array_length_t amount, f_uint32s_t *uint32s) {
+ #ifndef _di_level_0_parameter_checking_
+ if (!amount) return F_status_set_error(F_parameter);
+ if (!uint32s) return F_status_set_error(F_parameter);
+ #endif // _di_level_0_parameter_checking_
+
+ if (uint32s->size - amount > 0) {
+ return private_f_type_uint32s_resize(uint32s->size - amount, uint32s);
+ }
+
+ return private_f_type_uint32s_resize(0, uint32s);
+ }
+#endif // _di_f_type_uint32s_decrease_by_
+
+#ifndef _di_f_type_uint32s_increase_
+ f_status_t f_type_uint32s_increase(f_uint32s_t *uint32s) {
+ #ifndef _di_level_0_parameter_checking_
+ if (!uint32s) return F_status_set_error(F_parameter);
+ #endif // _di_level_0_parameter_checking_
+
+ if (uint32s->used + 1 > uint32s->size) {
+ f_array_length_t size = uint32s->used + f_memory_default_allocation_step;
+
+ if (size > f_array_length_t_size) {
+ if (uint32s->used + 1 > f_array_length_t_size) {
+ return F_status_set_error(F_array_too_large);
+ }
+
+ size = f_array_length_t_size;
+ }
+
+ return private_f_type_uint32s_resize(size, uint32s);
+ }
+
+ return F_data_not;
+ }
+#endif // _di_f_type_uint32s_increase_
+
+#ifndef _di_f_type_uint32s_increase_by_
+ f_status_t f_type_uint32s_increase_by(const f_array_length_t amount, f_uint32s_t *uint32s) {
+ #ifndef _di_level_0_parameter_checking_
+ if (!amount) return F_status_set_error(F_parameter);
+ if (!uint32s) return F_status_set_error(F_parameter);
+ #endif // _di_level_0_parameter_checking_
+
+ if (uint32s->used + amount > uint32s->size) {
+ if (uint32s->used + amount > f_array_length_t_size) {
+ return F_status_set_error(F_array_too_large);
+ }
+
+ return private_f_type_uint32s_resize(uint32s->used + amount, uint32s);
+ }
+
+ return F_data_not;
+ }
+#endif // _di_f_type_uint32s_increase_by_
+
+#ifndef _di_f_type_uint32s_resize_
+ f_status_t f_type_uint32s_resize(const f_array_length_t length, f_uint32s_t *uint32s) {
+ #ifndef _di_level_0_parameter_checking_
+ if (!uint32s) return F_status_set_error(F_parameter);
+ #endif // _di_level_0_parameter_checking_
+
+ return private_f_type_uint32s_resize(length, uint32s);
+ }
+#endif // _di_f_type_uint32s_resize_
+
+#ifndef _di_f_type_uint32ss_adjust_
+ f_status_t f_type_uint32ss_adjust(const f_array_length_t length, f_uint32ss_t *uint32ss) {
+ #ifndef _di_level_0_parameter_checking_
+ if (!uint32ss) return F_status_set_error(F_parameter);
+ #endif // _di_level_0_parameter_checking_
+
+ return private_f_type_uint32ss_adjust(length, uint32ss);
+ }
+#endif // _di_f_type_uint32ss_adjust_
+
+#ifndef _di_f_type_uint32ss_append_
+ f_status_t f_type_uint32ss_append(const f_uint32ss_t source, f_uint32ss_t *destination) {
+ #ifndef _di_level_0_parameter_checking_
+ if (!destination) return F_status_set_error(F_parameter);
+ #endif // _di_level_0_parameter_checking_
+
+ f_status_t status = F_none;
+
+ if (destination->used + source.used > destination->size) {
+ status = private_f_type_uint32ss_resize(destination->used + source.used, destination);
+ if (F_status_is_error(status)) return status;
+ }
+
+ for (f_array_length_t i = 0; i < source.used; ++i, ++destination->used) {
+ status = private_f_type_uint32s_append(source.array[i], &destination->array[destination->used]);
+ if (F_status_is_error(status)) return status;
+ } // for
+
+ return F_none;
+ }
+#endif // _di_f_type_uint32ss_append_
+
+#ifndef _di_f_type_uint32ss_decimate_by_
+ f_status_t f_type_uint32ss_decimate_by(const f_array_length_t amount, f_uint32ss_t *uint32ss) {
+ #ifndef _di_level_0_parameter_checking_
+ if (!amount) return F_status_set_error(F_parameter);
+ if (!uint32ss) return F_status_set_error(F_parameter);
+ #endif // _di_level_0_parameter_checking_
+
+ if (uint32ss->size - amount > 0) {
+ return private_f_type_uint32ss_adjust(uint32ss->size - amount, uint32ss);
+ }
+
+ return private_f_type_uint32ss_adjust(0, uint32ss);
+ }
+#endif // _di_f_type_uint32ss_decimate_by_
+
+#ifndef _di_f_type_uint32ss_decrease_by_
+ f_status_t f_type_uint32ss_decrease_by(const f_array_length_t amount, f_uint32ss_t *uint32ss) {
+ #ifndef _di_level_0_parameter_checking_
+ if (!amount) return F_status_set_error(F_parameter);
+ if (!uint32ss) return F_status_set_error(F_parameter);
+ #endif // _di_level_0_parameter_checking_
+
+ if (uint32ss->size - amount > 0) {
+ return private_f_type_uint32ss_resize(uint32ss->size - amount, uint32ss);
+ }
+
+ return private_f_type_uint32ss_resize(0, uint32ss);
+ }
+#endif // _di_f_type_uint32ss_decrease_by_
+
+#ifndef _di_f_type_uint32ss_increase_
+ f_status_t f_type_uint32ss_increase(f_uint32ss_t *uint32ss) {
+ #ifndef _di_level_0_parameter_checking_
+ if (!uint32ss) return F_status_set_error(F_parameter);
+ #endif // _di_level_0_parameter_checking_
+
+ if (uint32ss->used + 1 > uint32ss->size) {
+ f_array_length_t size = uint32ss->used + f_memory_default_allocation_step;
+
+ if (size > f_array_length_t_size) {
+ if (uint32ss->used + 1 > f_array_length_t_size) {
+ return F_status_set_error(F_array_too_large);
+ }
+
+ size = f_array_length_t_size;
+ }
+
+ return private_f_type_uint32ss_resize(size, uint32ss);
+ }
+
+ return F_data_not;
+ }
+#endif // _di_f_type_uint32ss_increase_
+
+#ifndef _di_f_type_uint32ss_increase_by_
+ f_status_t f_type_uint32ss_increase_by(const f_array_length_t amount, f_uint32ss_t *uint32ss) {
+ #ifndef _di_level_0_parameter_checking_
+ if (!amount) return F_status_set_error(F_parameter);
+ if (!uint32ss) return F_status_set_error(F_parameter);
+ #endif // _di_level_0_parameter_checking_
+
+ if (uint32ss->used + amount > uint32ss->size) {
+ if (uint32ss->used + amount > f_array_length_t_size) {
+ return F_status_set_error(F_array_too_large);
+ }
+
+ return private_f_type_uint32ss_resize(uint32ss->used + amount, uint32ss);
+ }
+
+ return F_data_not;
+ }
+#endif // _di_f_type_uint32ss_increase_by_
+
+#ifndef _di_f_type_uint32ss_resize_
+ f_status_t f_type_uint32ss_resize(const f_array_length_t length, f_uint32ss_t *uint32ss) {
+ #ifndef _di_level_0_parameter_checking_
+ if (!uint32ss) return F_status_set_error(F_parameter);
+ #endif // _di_level_0_parameter_checking_
+
+ return private_f_type_uint32ss_resize(length, uint32ss);
+ }
+#endif // _di_f_type_uint32ss_resize_
+
+#ifndef _di_f_type_int64s_adjust_
+ f_status_t f_type_int64s_adjust(const f_array_length_t length, f_int64s_t *int64s) {
+ #ifndef _di_level_0_parameter_checking_
+ if (!int64s) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
- return private_f_type_int32ss_resize(length, int32ss);
+ return private_f_type_int64s_adjust(length, int64s);
}
-#endif // _di_f_type_int32ss_resize_
+#endif // _di_f_type_int64s_adjust_
-#ifndef _di_f_type_uint32ss_adjust_
- f_status_t f_type_uint32ss_adjust(const f_array_length_t length, f_uint32ss_t *uint32ss) {
+#ifndef _di_f_type_int64s_append_
+ f_status_t f_type_int64s_append(const f_int64s_t source, f_int64s_t *destination) {
#ifndef _di_level_0_parameter_checking_
- if (!uint32ss) return F_status_set_error(F_parameter);
+ if (!destination) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
- return private_f_type_uint32ss_adjust(length, uint32ss);
+ return private_f_type_int64s_append(source, destination);
}
-#endif // _di_f_type_uint32ss_adjust_
+#endif // _di_f_type_int64s_append_
-#ifndef _di_f_type_uint32ss_decimate_by_
- f_status_t f_type_uint32ss_decimate_by(const f_array_length_t amount, f_uint32ss_t *uint32ss) {
+#ifndef _di_f_type_int64s_decimate_by_
+ f_status_t f_type_int64s_decimate_by(const f_array_length_t amount, f_int64s_t *int64s) {
#ifndef _di_level_0_parameter_checking_
if (!amount) return F_status_set_error(F_parameter);
- if (!uint32ss) return F_status_set_error(F_parameter);
+ if (!int64s) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
- if (uint32ss->size - amount > 0) {
- return private_f_type_uint32ss_adjust(uint32ss->size - amount, uint32ss);
+ if (int64s->size - amount > 0) {
+ return private_f_type_int64s_adjust(int64s->size - amount, int64s);
}
- return private_f_type_uint32ss_adjust(0, uint32ss);
+ return private_f_type_int64s_adjust(0, int64s);
}
-#endif // _di_f_type_uint32ss_decimate_by_
+#endif // _di_f_type_int64s_decimate_by_
-#ifndef _di_f_type_uint32ss_decrease_by_
- f_status_t f_type_uint32ss_decrease_by(const f_array_length_t amount, f_uint32ss_t *uint32ss) {
+#ifndef _di_f_type_int64s_decrease_by_
+ f_status_t f_type_int64s_decrease_by(const f_array_length_t amount, f_int64s_t *int64s) {
#ifndef _di_level_0_parameter_checking_
if (!amount) return F_status_set_error(F_parameter);
- if (!uint32ss) return F_status_set_error(F_parameter);
+ if (!int64s) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
- if (uint32ss->size - amount > 0) {
- return private_f_type_uint32ss_resize(uint32ss->size - amount, uint32ss);
+ if (int64s->size - amount > 0) {
+ return private_f_type_int64s_resize(int64s->size - amount, int64s);
}
- return private_f_type_uint32ss_resize(0, uint32ss);
+ return private_f_type_int64s_resize(0, int64s);
}
-#endif // _di_f_type_uint32ss_decrease_by_
+#endif // _di_f_type_int64s_decrease_by_
-#ifndef _di_f_type_uint32ss_increase_
- f_status_t f_type_uint32ss_increase(f_uint32ss_t *uint32ss) {
+#ifndef _di_f_type_int64s_increase_
+ f_status_t f_type_int64s_increase(f_int64s_t *int64s) {
#ifndef _di_level_0_parameter_checking_
- if (!uint32ss) return F_status_set_error(F_parameter);
+ if (!int64s) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
- if (uint32ss->used + 1 > uint32ss->size) {
- f_array_length_t size = uint32ss->used + f_memory_default_allocation_step;
+ if (int64s->used + 1 > int64s->size) {
+ f_array_length_t size = int64s->used + f_memory_default_allocation_step;
if (size > f_array_length_t_size) {
- if (uint32ss->used + 1 > f_array_length_t_size) {
+ if (int64s->used + 1 > f_array_length_t_size) {
return F_status_set_error(F_array_too_large);
}
size = f_array_length_t_size;
}
- return private_f_type_uint32ss_resize(size, uint32ss);
+ return private_f_type_int64s_resize(size, int64s);
}
return F_data_not;
}
-#endif // _di_f_type_uint32ss_increase_
+#endif // _di_f_type_int64s_increase_
-#ifndef _di_f_type_uint32ss_increase_by_
- f_status_t f_type_uint32ss_increase_by(const f_array_length_t amount, f_uint32ss_t *uint32ss) {
+#ifndef _di_f_type_int64s_increase_by_
+ f_status_t f_type_int64s_increase_by(const f_array_length_t amount, f_int64s_t *int64s) {
#ifndef _di_level_0_parameter_checking_
if (!amount) return F_status_set_error(F_parameter);
- if (!uint32ss) return F_status_set_error(F_parameter);
+ if (!int64s) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
- if (uint32ss->used + amount > uint32ss->size) {
- if (uint32ss->used + amount > f_array_length_t_size) {
+ if (int64s->used + amount > int64s->size) {
+ if (int64s->used + amount > f_array_length_t_size) {
return F_status_set_error(F_array_too_large);
}
- return private_f_type_uint32ss_resize(uint32ss->used + amount, uint32ss);
+ return private_f_type_int64s_resize(int64s->used + amount, int64s);
}
return F_data_not;
}
-#endif // _di_f_type_uint32ss_increase_by_
+#endif // _di_f_type_int64s_increase_by_
-#ifndef _di_f_type_uint32ss_resize_
- f_status_t f_type_uint32ss_resize(const f_array_length_t length, f_uint32ss_t *uint32ss) {
+#ifndef _di_f_type_int64s_resize_
+ f_status_t f_type_int64s_resize(const f_array_length_t length, f_int64s_t *int64s) {
#ifndef _di_level_0_parameter_checking_
- if (!uint32ss) return F_status_set_error(F_parameter);
+ if (!int64s) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
- return private_f_type_uint32ss_resize(length, uint32ss);
+ return private_f_type_int64s_resize(length, int64s);
}
-#endif // _di_f_type_uint32ss_resize_
+#endif // _di_f_type_int64s_resize_
#ifndef _di_f_type_int64ss_adjust_
f_status_t f_type_int64ss_adjust(const f_array_length_t length, f_int64ss_t *int64ss) {
}
#endif // _di_f_type_int64ss_adjust_
+#ifndef _di_f_type_int64ss_append_
+ f_status_t f_type_int64ss_append(const f_int64ss_t source, f_int64ss_t *destination) {
+ #ifndef _di_level_0_parameter_checking_
+ if (!destination) return F_status_set_error(F_parameter);
+ #endif // _di_level_0_parameter_checking_
+
+ f_status_t status = F_none;
+
+ if (destination->used + source.used > destination->size) {
+ status = private_f_type_int64ss_resize(destination->used + source.used, destination);
+ if (F_status_is_error(status)) return status;
+ }
+
+ for (f_array_length_t i = 0; i < source.used; ++i, ++destination->used) {
+ status = private_f_type_int64s_append(source.array[i], &destination->array[destination->used]);
+ if (F_status_is_error(status)) return status;
+ } // for
+
+ return F_none;
+ }
+#endif // _di_f_type_int64ss_append_
+
#ifndef _di_f_type_int64ss_decimate_by_
f_status_t f_type_int64ss_decimate_by(const f_array_length_t amount, f_int64ss_t *int64ss) {
#ifndef _di_level_0_parameter_checking_
}
#endif // _di_f_type_int64ss_resize_
+#ifndef _di_f_type_uint64s_adjust_
+ f_status_t f_type_uint64s_adjust(const f_array_length_t length, f_uint64s_t *uint64s) {
+ #ifndef _di_level_0_parameter_checking_
+ if (!uint64s) return F_status_set_error(F_parameter);
+ #endif // _di_level_0_parameter_checking_
+
+ return private_f_type_uint64s_adjust(length, uint64s);
+ }
+#endif // _di_f_type_uint64s_adjust_
+
+#ifndef _di_f_type_uint64s_append_
+ f_status_t f_type_uint64s_append(const f_uint64s_t source, f_uint64s_t *destination) {
+ #ifndef _di_level_0_parameter_checking_
+ if (!destination) return F_status_set_error(F_parameter);
+ #endif // _di_level_0_parameter_checking_
+
+ return private_f_type_uint64s_append(source, destination);
+ }
+#endif // _di_f_type_uint64s_append_
+
+#ifndef _di_f_type_uint64s_decimate_by_
+ f_status_t f_type_uint64s_decimate_by(const f_array_length_t amount, f_uint64s_t *uint64s) {
+ #ifndef _di_level_0_parameter_checking_
+ if (!amount) return F_status_set_error(F_parameter);
+ if (!uint64s) return F_status_set_error(F_parameter);
+ #endif // _di_level_0_parameter_checking_
+
+ if (uint64s->size - amount > 0) {
+ return private_f_type_uint64s_adjust(uint64s->size - amount, uint64s);
+ }
+
+ return private_f_type_uint64s_adjust(0, uint64s);
+ }
+#endif // _di_f_type_uint64s_decimate_by_
+
+#ifndef _di_f_type_uint64s_decrease_by_
+ f_status_t f_type_uint64s_decrease_by(const f_array_length_t amount, f_uint64s_t *uint64s) {
+ #ifndef _di_level_0_parameter_checking_
+ if (!amount) return F_status_set_error(F_parameter);
+ if (!uint64s) return F_status_set_error(F_parameter);
+ #endif // _di_level_0_parameter_checking_
+
+ if (uint64s->size - amount > 0) {
+ return private_f_type_uint64s_resize(uint64s->size - amount, uint64s);
+ }
+
+ return private_f_type_uint64s_resize(0, uint64s);
+ }
+#endif // _di_f_type_uint64s_decrease_by_
+
+#ifndef _di_f_type_uint64s_increase_
+ f_status_t f_type_uint64s_increase(f_uint64s_t *uint64s) {
+ #ifndef _di_level_0_parameter_checking_
+ if (!uint64s) return F_status_set_error(F_parameter);
+ #endif // _di_level_0_parameter_checking_
+
+ if (uint64s->used + 1 > uint64s->size) {
+ f_array_length_t size = uint64s->used + f_memory_default_allocation_step;
+
+ if (size > f_array_length_t_size) {
+ if (uint64s->used + 1 > f_array_length_t_size) {
+ return F_status_set_error(F_array_too_large);
+ }
+
+ size = f_array_length_t_size;
+ }
+
+ return private_f_type_uint64s_resize(size, uint64s);
+ }
+
+ return F_data_not;
+ }
+#endif // _di_f_type_uint64s_increase_
+
+#ifndef _di_f_type_uint64s_increase_by_
+ f_status_t f_type_uint64s_increase_by(const f_array_length_t amount, f_uint64s_t *uint64s) {
+ #ifndef _di_level_0_parameter_checking_
+ if (!amount) return F_status_set_error(F_parameter);
+ if (!uint64s) return F_status_set_error(F_parameter);
+ #endif // _di_level_0_parameter_checking_
+
+ if (uint64s->used + amount > uint64s->size) {
+ if (uint64s->used + amount > f_array_length_t_size) {
+ return F_status_set_error(F_array_too_large);
+ }
+
+ return private_f_type_uint64s_resize(uint64s->used + amount, uint64s);
+ }
+
+ return F_data_not;
+ }
+#endif // _di_f_type_uint64s_increase_by_
+
+#ifndef _di_f_type_uint64s_resize_
+ f_status_t f_type_uint64s_resize(const f_array_length_t length, f_uint64s_t *uint64s) {
+ #ifndef _di_level_0_parameter_checking_
+ if (!uint64s) return F_status_set_error(F_parameter);
+ #endif // _di_level_0_parameter_checking_
+
+ return private_f_type_uint64s_resize(length, uint64s);
+ }
+#endif // _di_f_type_uint64s_resize_
+
#ifndef _di_f_type_uint64ss_adjust_
f_status_t f_type_uint64ss_adjust(const f_array_length_t length, f_uint64ss_t *uint64ss) {
#ifndef _di_level_0_parameter_checking_
}
#endif // _di_f_type_uint64ss_adjust_
+#ifndef _di_f_type_uint64ss_append_
+ f_status_t f_type_uint64ss_append(const f_uint64ss_t source, f_uint64ss_t *destination) {
+ #ifndef _di_level_0_parameter_checking_
+ if (!destination) return F_status_set_error(F_parameter);
+ #endif // _di_level_0_parameter_checking_
+
+ f_status_t status = F_none;
+
+ if (destination->used + source.used > destination->size) {
+ status = private_f_type_uint64ss_resize(destination->used + source.used, destination);
+ if (F_status_is_error(status)) return status;
+ }
+
+ for (f_array_length_t i = 0; i < source.used; ++i, ++destination->used) {
+ status = private_f_type_uint64s_append(source.array[i], &destination->array[destination->used]);
+ if (F_status_is_error(status)) return status;
+ } // for
+
+ return F_none;
+ }
+#endif // _di_f_type_uint64ss_append_
+
#ifndef _di_f_type_uint64ss_decimate_by_
f_status_t f_type_uint64ss_decimate_by(const f_array_length_t amount, f_uint64ss_t *uint64ss) {
#ifndef _di_level_0_parameter_checking_
}
#endif // _di_f_type_uint64ss_resize_
+#ifndef _di_f_type_int128s_adjust_
+ f_status_t f_type_int128s_adjust(const f_array_length_t length, f_int128s_t *int128s) {
+ #ifndef _di_level_0_parameter_checking_
+ if (!int128s) return F_status_set_error(F_parameter);
+ #endif // _di_level_0_parameter_checking_
+
+ return private_f_type_int128s_adjust(length, int128s);
+ }
+#endif // _di_f_type_int128s_adjust_
+
+#ifndef _di_f_type_int128s_append_
+ f_status_t f_type_int128s_append(const f_int128s_t source, f_int128s_t *destination) {
+ #ifndef _di_level_0_parameter_checking_
+ if (!destination) return F_status_set_error(F_parameter);
+ #endif // _di_level_0_parameter_checking_
+
+ return private_f_type_int128s_append(source, destination);
+ }
+#endif // _di_f_type_int128s_append_
+
+#ifndef _di_f_type_int128s_decimate_by_
+ f_status_t f_type_int128s_decimate_by(const f_array_length_t amount, f_int128s_t *int128s) {
+ #ifndef _di_level_0_parameter_checking_
+ if (!amount) return F_status_set_error(F_parameter);
+ if (!int128s) return F_status_set_error(F_parameter);
+ #endif // _di_level_0_parameter_checking_
+
+ if (int128s->size - amount > 0) {
+ return private_f_type_int128s_adjust(int128s->size - amount, int128s);
+ }
+
+ return private_f_type_int128s_adjust(0, int128s);
+ }
+#endif // _di_f_type_int128s_decimate_by_
+
+#ifndef _di_f_type_int128s_decrease_by_
+ f_status_t f_type_int128s_decrease_by(const f_array_length_t amount, f_int128s_t *int128s) {
+ #ifndef _di_level_0_parameter_checking_
+ if (!amount) return F_status_set_error(F_parameter);
+ if (!int128s) return F_status_set_error(F_parameter);
+ #endif // _di_level_0_parameter_checking_
+
+ if (int128s->size - amount > 0) {
+ return private_f_type_int128s_resize(int128s->size - amount, int128s);
+ }
+
+ return private_f_type_int128s_resize(0, int128s);
+ }
+#endif // _di_f_type_int128s_decrease_by_
+
+#ifndef _di_f_type_int128s_increase_
+ f_status_t f_type_int128s_increase(f_int128s_t *int128s) {
+ #ifndef _di_level_0_parameter_checking_
+ if (!int128s) return F_status_set_error(F_parameter);
+ #endif // _di_level_0_parameter_checking_
+
+ if (int128s->used + 1 > int128s->size) {
+ f_array_length_t size = int128s->used + f_memory_default_allocation_step;
+
+ if (size > f_array_length_t_size) {
+ if (int128s->used + 1 > f_array_length_t_size) {
+ return F_status_set_error(F_array_too_large);
+ }
+
+ size = f_array_length_t_size;
+ }
+
+ return private_f_type_int128s_resize(size, int128s);
+ }
+
+ return F_data_not;
+ }
+#endif // _di_f_type_int128s_increase_
+
+#ifndef _di_f_type_int128s_increase_by_
+ f_status_t f_type_int128s_increase_by(const f_array_length_t amount, f_int128s_t *int128s) {
+ #ifndef _di_level_0_parameter_checking_
+ if (!amount) return F_status_set_error(F_parameter);
+ if (!int128s) return F_status_set_error(F_parameter);
+ #endif // _di_level_0_parameter_checking_
+
+ if (int128s->used + amount > int128s->size) {
+ if (int128s->used + amount > f_array_length_t_size) {
+ return F_status_set_error(F_array_too_large);
+ }
+
+ return private_f_type_int128s_resize(int128s->used + amount, int128s);
+ }
+
+ return F_data_not;
+ }
+#endif // _di_f_type_int128s_increase_by_
+
+#ifndef _di_f_type_int128s_resize_
+ f_status_t f_type_int128s_resize(const f_array_length_t length, f_int128s_t *int128s) {
+ #ifndef _di_level_0_parameter_checking_
+ if (!int128s) return F_status_set_error(F_parameter);
+ #endif // _di_level_0_parameter_checking_
+
+ return private_f_type_int128s_resize(length, int128s);
+ }
+#endif // _di_f_type_int128s_resize_
+
#ifndef _di_f_type_int128ss_adjust_
f_status_t f_type_int128ss_adjust(const f_array_length_t length, f_int128ss_t *int128ss) {
#ifndef _di_level_0_parameter_checking_
}
#endif // _di_f_type_int128ss_adjust_
+#ifndef _di_f_type_int128ss_append_
+ f_status_t f_type_int128ss_append(const f_int128ss_t source, f_int128ss_t *destination) {
+ #ifndef _di_level_0_parameter_checking_
+ if (!destination) return F_status_set_error(F_parameter);
+ #endif // _di_level_0_parameter_checking_
+
+ f_status_t status = F_none;
+
+ if (destination->used + source.used > destination->size) {
+ status = private_f_type_int128ss_resize(destination->used + source.used, destination);
+ if (F_status_is_error(status)) return status;
+ }
+
+ for (f_array_length_t i = 0; i < source.used; ++i, ++destination->used) {
+ status = private_f_type_int128s_append(source.array[i], &destination->array[destination->used]);
+ if (F_status_is_error(status)) return status;
+ } // for
+
+ return F_none;
+ }
+#endif // _di_f_type_int128ss_append_
+
#ifndef _di_f_type_int128ss_decimate_by_
f_status_t f_type_int128ss_decimate_by(const f_array_length_t amount, f_int128ss_t *int128ss) {
#ifndef _di_level_0_parameter_checking_
}
#endif // _di_f_type_int128ss_resize_
+#ifndef _di_f_type_uint128s_adjust_
+ f_status_t f_type_uint128s_adjust(const f_array_length_t length, f_uint128s_t *uint128s) {
+ #ifndef _di_level_0_parameter_checking_
+ if (!uint128s) return F_status_set_error(F_parameter);
+ #endif // _di_level_0_parameter_checking_
+
+ return private_f_type_uint128s_adjust(length, uint128s);
+ }
+#endif // _di_f_type_uint128s_adjust_
+
+#ifndef _di_f_type_uint128s_append_
+ f_status_t f_type_uint128s_append(const f_uint128s_t source, f_uint128s_t *destination) {
+ #ifndef _di_level_0_parameter_checking_
+ if (!destination) return F_status_set_error(F_parameter);
+ #endif // _di_level_0_parameter_checking_
+
+ return private_f_type_uint128s_append(source, destination);
+ }
+#endif // _di_f_type_uint128s_append_
+
+#ifndef _di_f_type_uint128s_decimate_by_
+ f_status_t f_type_uint128s_decimate_by(const f_array_length_t amount, f_uint128s_t *uint128s) {
+ #ifndef _di_level_0_parameter_checking_
+ if (!amount) return F_status_set_error(F_parameter);
+ if (!uint128s) return F_status_set_error(F_parameter);
+ #endif // _di_level_0_parameter_checking_
+
+ if (uint128s->size - amount > 0) {
+ return private_f_type_uint128s_adjust(uint128s->size - amount, uint128s);
+ }
+
+ return private_f_type_uint128s_adjust(0, uint128s);
+ }
+#endif // _di_f_type_uint128s_decimate_by_
+
+#ifndef _di_f_type_uint128s_decrease_by_
+ f_status_t f_type_uint128s_decrease_by(const f_array_length_t amount, f_uint128s_t *uint128s) {
+ #ifndef _di_level_0_parameter_checking_
+ if (!amount) return F_status_set_error(F_parameter);
+ if (!uint128s) return F_status_set_error(F_parameter);
+ #endif // _di_level_0_parameter_checking_
+
+ if (uint128s->size - amount > 0) {
+ return private_f_type_uint128s_resize(uint128s->size - amount, uint128s);
+ }
+
+ return private_f_type_uint128s_resize(0, uint128s);
+ }
+#endif // _di_f_type_uint128s_decrease_by_
+
+#ifndef _di_f_type_uint128s_increase_
+ f_status_t f_type_uint128s_increase(f_uint128s_t *uint128s) {
+ #ifndef _di_level_0_parameter_checking_
+ if (!uint128s) return F_status_set_error(F_parameter);
+ #endif // _di_level_0_parameter_checking_
+
+ if (uint128s->used + 1 > uint128s->size) {
+ f_array_length_t size = uint128s->used + f_memory_default_allocation_step;
+
+ if (size > f_array_length_t_size) {
+ if (uint128s->used + 1 > f_array_length_t_size) {
+ return F_status_set_error(F_array_too_large);
+ }
+
+ size = f_array_length_t_size;
+ }
+
+ return private_f_type_uint128s_resize(size, uint128s);
+ }
+
+ return F_data_not;
+ }
+#endif // _di_f_type_uint128s_increase_
+
+#ifndef _di_f_type_uint128s_increase_by_
+ f_status_t f_type_uint128s_increase_by(const f_array_length_t amount, f_uint128s_t *uint128s) {
+ #ifndef _di_level_0_parameter_checking_
+ if (!amount) return F_status_set_error(F_parameter);
+ if (!uint128s) return F_status_set_error(F_parameter);
+ #endif // _di_level_0_parameter_checking_
+
+ if (uint128s->used + amount > uint128s->size) {
+ if (uint128s->used + amount > f_array_length_t_size) {
+ return F_status_set_error(F_array_too_large);
+ }
+
+ return private_f_type_uint128s_resize(uint128s->used + amount, uint128s);
+ }
+
+ return F_data_not;
+ }
+#endif // _di_f_type_uint128s_increase_by_
+
+#ifndef _di_f_type_uint128s_resize_
+ f_status_t f_type_uint128s_resize(const f_array_length_t length, f_uint128s_t *uint128s) {
+ #ifndef _di_level_0_parameter_checking_
+ if (!uint128s) return F_status_set_error(F_parameter);
+ #endif // _di_level_0_parameter_checking_
+
+ return private_f_type_uint128s_resize(length, uint128s);
+ }
+#endif // _di_f_type_uint128s_resize_
+
#ifndef _di_f_type_uint128ss_adjust_
f_status_t f_type_uint128ss_adjust(const f_array_length_t length, f_uint128ss_t *uint128ss) {
#ifndef _di_level_0_parameter_checking_
}
#endif // _di_f_type_uint128ss_adjust_
+#ifndef _di_f_type_uint128ss_append_
+ f_status_t f_type_uint128ss_append(const f_uint128ss_t source, f_uint128ss_t *destination) {
+ #ifndef _di_level_0_parameter_checking_
+ if (!destination) return F_status_set_error(F_parameter);
+ #endif // _di_level_0_parameter_checking_
+
+ f_status_t status = F_none;
+
+ if (destination->used + source.used > destination->size) {
+ status = private_f_type_uint128ss_resize(destination->used + source.used, destination);
+ if (F_status_is_error(status)) return status;
+ }
+
+ for (f_array_length_t i = 0; i < source.used; ++i, ++destination->used) {
+ status = private_f_type_uint128s_append(source.array[i], &destination->array[destination->used]);
+ if (F_status_is_error(status)) return status;
+ } // for
+
+ return F_none;
+ }
+#endif // _di_f_type_uint128ss_append_
+
#ifndef _di_f_type_uint128ss_decimate_by_
f_status_t f_type_uint128ss_decimate_by(const f_array_length_t amount, f_uint128ss_t *uint128ss) {
#ifndef _di_level_0_parameter_checking_
#endif
/**
- * Resize the string cellss array.
+ * Resize the string cells array.
*
* @param length
* The new size to use.
- * @param cellss
- * The string cellss array to resize.
+ * @param cells
+ * The string cells array to resize.
*
* @return
* F_none on success.
*
- * F_memory_not (with error bit) on out of memory.
* F_parameter (with error bit) if a parameter is invalid.
+ *
+ * Errors (with error bit) from: f_memory_adjust().
*/
-#ifndef _di_f_type_cellss_adjust_
- extern f_status_t f_type_cellss_adjust(const f_array_length_t length, f_cellss_t *cellss);
-#endif // _di_f_type_cellss_adjust_
+#ifndef _di_f_type_cells_adjust_
+ extern f_status_t f_type_cells_adjust(const f_array_length_t length, f_cells_t *cells);
+#endif // _di_f_type_cells_adjust_
/**
- * Resize the string cellss array to a smaller size.
+ * Append the source cells onto the destination.
+ *
+ * @param source
+ * The source cells to append.
+ * @param destination
+ * The destination cells the source is appended onto.
+ *
+ * @return
+ * F_none on success.
+ *
+ * F_parameter (with error bit) if a parameter is invalid.
+ *
+ * Errors (with error bit) from: f_memory_resize().
+ */
+#ifndef _di_f_type_cells_append_
+ extern f_status_t f_type_cells_append(const f_cells_t source, f_cells_t *destination);
+#endif // _di_f_type_cells_append_
+
+/**
+ * Resize the string cells array to a smaller size.
*
* This will resize making the array smaller based on (size - given length).
* If the given length is too small, then the resize will fail.
- * This will not shrink the size to less than 0.
+ * This will not shrink the size to les than 0.
*
* @param amount
* A positive number representing how much to decimate the size by.
- * @param cellss
- * The string cellss array to resize.
+ * @param cells
+ * The string cells array to resize.
*
* @return
* F_none on success.
*
* F_memory_not (with error bit) on out of memory.
* F_parameter (with error bit) if a parameter is invalid.
+ *
+ * Errors (with error bit) from: f_memory_adjust().
*/
-#ifndef _di_f_type_cellss_decimate_by_
- extern f_status_t f_type_cellss_decimate_by(const f_array_length_t amount, f_cellss_t *cellss);
-#endif // _di_f_type_cellss_decimate_by_
+#ifndef _di_f_type_cells_decimate_by_
+ extern f_status_t f_type_cells_decimate_by(const f_array_length_t amount, f_cells_t *cells);
+#endif // _di_f_type_cells_decimate_by_
/**
- * Resize the string cellss array to a smaller size.
+ * Resize the string cells array to a smaller size.
*
* This will resize making the array smaller based on (size - given length).
* If the given length is too small, then the resize will fail.
- * This will not shrink the size to less than 0.
+ * This will not shrink the size to les than 0.
*
* @param amount
* A positive number representing how much to decrease the size by.
- * @param cellss
- * The string cellss array to resize.
+ * @param cells
+ * The string cells array to resize.
*
* @return
* F_none on success.
*
* F_memory_not (with error bit) on out of memory.
* F_parameter (with error bit) if a parameter is invalid.
+ *
+ * Errors (with error bit) from: f_memory_resize().
*/
-#ifndef _di_f_type_cellss_decrease_by_
- extern f_status_t f_type_cellss_decrease_by(const f_array_length_t amount, f_cellss_t *cellss);
-#endif // _di_f_type_cellss_decrease_by_
+#ifndef _di_f_type_cells_decrease_by_
+ extern f_status_t f_type_cells_decrease_by(const f_array_length_t amount, f_cells_t *cells);
+#endif // _di_f_type_cells_decrease_by_
/**
- * Increase the size of the string cellss array, but only if necessary.
+ * Increase the size of the string cells array, but only if necesary.
*
* If the given length is too large for the buffer, then attempt to set max buffer size (f_array_length_t_size).
* If already set to the maximum buffer size, then the resize will fail.
*
- * @param cellss
- * The string cellss array to resize.
+ * @param cells
+ * The string cells array to resize.
*
* @return
* F_none on success.
* F_array_too_large (with error bit) if the new array length is too large.
* F_memory_not (with error bit) on out of memory.
* F_parameter (with error bit) if a parameter is invalid.
+ *
+ * Errors (with error bit) from: f_memory_resize().
*/
-#ifndef _di_f_type_cellss_increase_
- extern f_status_t f_type_cellss_increase(f_cellss_t *cellss);
-#endif // _di_f_type_cellss_increase_
+#ifndef _di_f_type_cells_increase_
+ extern f_status_t f_type_cells_increase(f_cells_t *cells);
+#endif // _di_f_type_cells_increase_
/**
- * Resize the string cellss array to a larger size.
+ * Resize the string cells array to a larger size.
*
* This will resize making the string larger based on the given length.
* If the given length is too large for the buffer, then attempt to set max buffer size (f_array_length_t_size).
*
* @param amount
* A positive number representing how much to increase the size by.
- * @param cellss
- * The string cellss array to resize.
+ * @param cells
+ * The string cells array to resize.
*
* @return
* F_none on success.
* F_memory_not (with error bit) on out of memory.
* F_parameter (with error bit) if a parameter is invalid.
* F_array_too_large (with error bit) if the new array length is too large.
+ *
+ * Errors (with error bit) from: f_memory_resize().
*/
-#ifndef _di_f_type_cellss_increase_by_
- extern f_status_t f_type_cellss_increase_by(const f_array_length_t amount, f_cellss_t *cellss);
-#endif // _di_f_type_cellss_increase_by_
+#ifndef _di_f_type_cells_increase_by_
+ extern f_status_t f_type_cells_increase_by(const f_array_length_t amount, f_cells_t *cells);
+#endif // _di_f_type_cells_increase_by_
+
+/**
+ * Resize the string cells array.
+ *
+ * @param length
+ * The new size to use.
+ * @param cells
+ * The string cells array to adjust.
+ *
+ * @return
+ * F_none on success.
+ *
+ * F_memory_not (with error bit) on out of memory.
+ * F_parameter (with error bit) if a parameter is invalid.
+ *
+ * Errors (with error bit) from: f_memory_resize().
+ */
+#ifndef _di_f_type_cells_resize_
+ extern f_status_t f_type_cells_resize(const f_array_length_t length, f_cells_t *cells);
+#endif // _di_f_type_cells_resize_
/**
* Resize the string cellss array.
* @param length
* The new size to use.
* @param cellss
- * The string cellss array to adjust.
+ * The string cellss array to resize.
+ *
+ * @return
+ * F_none on success.
+ *
+ * F_memory_not (with error bit) on out of memory.
+ * F_parameter (with error bit) if a parameter is invalid.
+ *
+ * Errors (with error bit) from: f_memory_adjust().
+ * Errors (with error bit) from: f_memory_destroy().
+ */
+#ifndef _di_f_type_cellss_adjust_
+ extern f_status_t f_type_cellss_adjust(const f_array_length_t length, f_cellss_t *cellss);
+#endif // _di_f_type_cellss_adjust_
+
+/**
+ * Append the source cellss onto the destination.
+ *
+ * @param source
+ * The source cellss to append.
+ * @param destination
+ * The destination ranges the source is appended onto.
*
* @return
* F_none on success.
*
* F_memory_not (with error bit) on out of memory.
* F_parameter (with error bit) if a parameter is invalid.
+ *
+ * Errors (with error bit) from: f_memory_resize().
*/
-#ifndef _di_f_type_cellss_resize_
- extern f_status_t f_type_cellss_resize(const f_array_length_t length, f_cellss_t *cellss);
-#endif // _di_f_type_cellss_resize_
+#ifndef _di_f_type_cellss_append_
+ extern f_status_t f_type_cellss_append(const f_cellss_t source, f_cellss_t *destination);
+#endif // _di_f_type_cellss_append_
/**
- * Resize the string array_lengthss array.
+ * Resize the string cellss array.
*
* @param length
* The new size to use.
- * @param array_lengthss
- * The string array_lengthss array to resize.
+ * @param cellss
+ * The string cellss array to resize.
*
* @return
* F_none on success.
*
* F_memory_not (with error bit) on out of memory.
* F_parameter (with error bit) if a parameter is invalid.
+ *
+ * Errors (with error bit) from: f_memory_adjust().
+ * Errors (with error bit) from: f_memory_destroy().
*/
-#ifndef _di_f_type_array_lengthss_adjust_
- extern f_status_t f_type_array_lengthss_adjust(const f_array_length_t length, f_array_lengthss_t *array_lengthss);
-#endif // _di_f_type_array_lengthss_adjust_
+#ifndef _di_f_type_cellss_adjust_
+ extern f_status_t f_type_cellss_adjust(const f_array_length_t length, f_cellss_t *cellss);
+#endif // _di_f_type_cellss_adjust_
/**
- * Resize the string array_lengthss array to a smaller size.
+ * Resize the string cellss array to a smaller size.
*
* This will resize making the array smaller based on (size - given length).
* If the given length is too small, then the resize will fail.
*
* @param amount
* A positive number representing how much to decimate the size by.
- * @param array_lengthss
- * The string array_lengthss array to resize.
+ * @param cellss
+ * The string cellss array to resize.
*
* @return
* F_none on success.
*
* F_memory_not (with error bit) on out of memory.
* F_parameter (with error bit) if a parameter is invalid.
+ *
+ * Errors (with error bit) from: f_memory_adjust().
+ * Errors (with error bit) from: f_memory_destroy().
*/
-#ifndef _di_f_type_array_lengthss_decimate_by_
- extern f_status_t f_type_array_lengthss_decimate_by(const f_array_length_t amount, f_array_lengthss_t *array_lengthss);
-#endif // _di_f_type_array_lengthss_decimate_by_
+#ifndef _di_f_type_cellss_decimate_by_
+ extern f_status_t f_type_cellss_decimate_by(const f_array_length_t amount, f_cellss_t *cellss);
+#endif // _di_f_type_cellss_decimate_by_
/**
- * Resize the string array_lengthss array to a smaller size.
+ * Resize the string cellss array to a smaller size.
*
* This will resize making the array smaller based on (size - given length).
* If the given length is too small, then the resize will fail.
*
* @param amount
* A positive number representing how much to decrease the size by.
- * @param array_lengthss
- * The string array_lengthss array to resize.
+ * @param cellss
+ * The string cellss array to resize.
*
* @return
* F_none on success.
*
* F_memory_not (with error bit) on out of memory.
* F_parameter (with error bit) if a parameter is invalid.
+ *
+ * Errors (with error bit) from: f_memory_delete().
+ * Errors (with error bit) from: f_memory_resize().
*/
-#ifndef _di_f_type_array_lengthss_decrease_by_
- extern f_status_t f_type_array_lengthss_decrease_by(const f_array_length_t amount, f_array_lengthss_t *array_lengthss);
-#endif // _di_f_type_array_lengthss_decrease_by_
+#ifndef _di_f_type_cellss_decrease_by_
+ extern f_status_t f_type_cellss_decrease_by(const f_array_length_t amount, f_cellss_t *cellss);
+#endif // _di_f_type_cellss_decrease_by_
/**
- * Increase the size of the string array_lengthss array, but only if necessary.
+ * Increase the size of the string cellss array, but only if necessary.
*
* If the given length is too large for the buffer, then attempt to set max buffer size (f_array_length_t_size).
* If already set to the maximum buffer size, then the resize will fail.
*
- * @param array_lengthss
- * The string array_lengthss array to resize.
+ * @param cellss
+ * The string cellss array to resize.
*
* @return
* F_none on success.
* F_array_too_large (with error bit) if the new array length is too large.
* F_memory_not (with error bit) on out of memory.
* F_parameter (with error bit) if a parameter is invalid.
+ *
+ * Errors (with error bit) from: f_memory_resize().
*/
-#ifndef _di_f_type_array_lengthss_increase_
- extern f_status_t f_type_array_lengthss_increase(f_array_lengthss_t *array_lengthss);
-#endif // _di_f_type_array_lengthss_increase_
+#ifndef _di_f_type_cellss_increase_
+ extern f_status_t f_type_cellss_increase(f_cellss_t *cellss);
+#endif // _di_f_type_cellss_increase_
/**
- * Resize the string array_lengthss array to a larger size.
+ * Resize the string cellss array to a larger size.
*
* This will resize making the string larger based on the given length.
* If the given length is too large for the buffer, then attempt to set max buffer size (f_array_length_t_size).
*
* @param amount
* A positive number representing how much to increase the size by.
- * @param array_lengthss
- * The string array_lengthss array to resize.
+ * @param cellss
+ * The string cellss array to resize.
*
* @return
* F_none on success.
* F_memory_not (with error bit) on out of memory.
* F_parameter (with error bit) if a parameter is invalid.
* F_array_too_large (with error bit) if the new array length is too large.
+ *
+ * Errors (with error bit) from: f_memory_resize().
*/
-#ifndef _di_f_type_array_lengthss_increase_by_
- extern f_status_t f_type_array_lengthss_increase_by(const f_array_length_t amount, f_array_lengthss_t *array_lengthss);
-#endif // _di_f_type_array_lengthss_increase_by_
+#ifndef _di_f_type_cellss_increase_by_
+ extern f_status_t f_type_cellss_increase_by(const f_array_length_t amount, f_cellss_t *cellss);
+#endif // _di_f_type_cellss_increase_by_
/**
- * Resize the string array_lengthss array.
+ * Resize the string cellss array.
*
* @param length
* The new size to use.
- * @param array_lengthss
- * The string array_lengthss array to adjust.
+ * @param cellss
+ * The string cellss array to adjust.
*
* @return
* F_none on success.
*
* F_memory_not (with error bit) on out of memory.
* F_parameter (with error bit) if a parameter is invalid.
+ *
+ * Errors (with error bit) from: f_memory_delete().
+ * Errors (with error bit) from: f_memory_resize().
*/
-#ifndef _di_f_type_array_lengthss_resize_
- extern f_status_t f_type_array_lengthss_resize(const f_array_length_t length, f_array_lengthss_t *array_lengthss);
-#endif // _di_f_type_array_lengthss_resize_
+#ifndef _di_f_type_cellss_resize_
+ extern f_status_t f_type_cellss_resize(const f_array_length_t length, f_cellss_t *cellss);
+#endif // _di_f_type_cellss_resize_
/**
- * Resize the string int8ss array.
+ * Resize the string lengths array.
*
* @param length
* The new size to use.
- * @param int8ss
- * The string int8ss array to resize.
+ * @param lengths
+ * The string lengths array to resize.
*
* @return
* F_none on success.
*
- * F_memory_not (with error bit) on out of memory.
* F_parameter (with error bit) if a parameter is invalid.
+ *
+ * Errors (with error bit) from: f_memory_adjust().
*/
-#ifndef _di_f_type_int8ss_adjust_
- extern f_status_t f_type_int8ss_adjust(const f_array_length_t length, f_int8ss_t *int8ss);
-#endif // _di_f_type_int8ss_adjust_
+#ifndef _di_f_type_array_lengths_adjust_
+ extern f_status_t f_type_array_lengths_adjust(const f_array_length_t length, f_array_lengths_t *lengths);
+#endif // _di_f_type_array_lengths_adjust_
/**
- * Resize the string int8ss array to a smaller size.
+ * Append the source lengths onto the destination.
+ *
+ * @param source
+ * The source lengths to append.
+ * @param destination
+ * The destination lengths the source is appended onto.
+ *
+ * @return
+ * F_none on success.
+ *
+ * F_parameter (with error bit) if a parameter is invalid.
+ *
+ * Errors (with error bit) from: f_memory_resize().
+ */
+#ifndef _di_f_type_array_lengths_append_
+ extern f_status_t f_type_array_lengths_append(const f_array_lengths_t source, f_array_lengths_t *destination);
+#endif // _di_f_type_array_lengths_append_
+
+/**
+ * Resize the string lengths array to a smaller size.
*
* This will resize making the array smaller based on (size - given length).
* If the given length is too small, then the resize will fail.
- * This will not shrink the size to less than 0.
+ * This will not shrink the size to les than 0.
*
* @param amount
* A positive number representing how much to decimate the size by.
- * @param int8ss
- * The string int8ss array to resize.
+ * @param lengths
+ * The string lengths array to resize.
*
* @return
* F_none on success.
*
* F_memory_not (with error bit) on out of memory.
* F_parameter (with error bit) if a parameter is invalid.
+ *
+ * Errors (with error bit) from: f_memory_adjust().
*/
-#ifndef _di_f_type_int8ss_decimate_by_
- extern f_status_t f_type_int8ss_decimate_by(const f_array_length_t amount, f_int8ss_t *int8ss);
-#endif // _di_f_type_int8ss_decimate_by_
+#ifndef _di_f_type_array_lengths_decimate_by_
+ extern f_status_t f_type_array_lengths_decimate_by(const f_array_length_t amount, f_array_lengths_t *lengths);
+#endif // _di_f_type_array_lengths_decimate_by_
/**
- * Resize the string int8ss array to a smaller size.
+ * Resize the string lengths array to a smaller size.
*
* This will resize making the array smaller based on (size - given length).
* If the given length is too small, then the resize will fail.
- * This will not shrink the size to less than 0.
+ * This will not shrink the size to les than 0.
*
* @param amount
* A positive number representing how much to decrease the size by.
- * @param int8ss
- * The string int8ss array to resize.
+ * @param lengths
+ * The string lengths array to resize.
*
* @return
* F_none on success.
*
* F_memory_not (with error bit) on out of memory.
* F_parameter (with error bit) if a parameter is invalid.
+ *
+ * Errors (with error bit) from: f_memory_resize().
*/
-#ifndef _di_f_type_int8ss_decrease_by_
- extern f_status_t f_type_int8ss_decrease_by(const f_array_length_t amount, f_int8ss_t *int8ss);
-#endif // _di_f_type_int8ss_decrease_by_
+#ifndef _di_f_type_array_lengths_decrease_by_
+ extern f_status_t f_type_array_lengths_decrease_by(const f_array_length_t amount, f_array_lengths_t *lengths);
+#endif // _di_f_type_array_lengths_decrease_by_
/**
- * Increase the size of the string int8ss array, but only if necessary.
+ * Increase the size of the string lengths array, but only if necesary.
*
* If the given length is too large for the buffer, then attempt to set max buffer size (f_array_length_t_size).
* If already set to the maximum buffer size, then the resize will fail.
*
- * @param int8ss
- * The string int8ss array to resize.
+ * @param lengths
+ * The string lengths array to resize.
*
* @return
* F_none on success.
* F_array_too_large (with error bit) if the new array length is too large.
* F_memory_not (with error bit) on out of memory.
* F_parameter (with error bit) if a parameter is invalid.
+ *
+ * Errors (with error bit) from: f_memory_resize().
*/
-#ifndef _di_f_type_int8ss_increase_
- extern f_status_t f_type_int8ss_increase(f_int8ss_t *int8ss);
-#endif // _di_f_type_int8ss_increase_
+#ifndef _di_f_type_array_lengths_increase_
+ extern f_status_t f_type_array_lengths_increase(f_array_lengths_t *lengths);
+#endif // _di_f_type_array_lengths_increase_
/**
- * Resize the string int8ss array to a larger size.
+ * Resize the string lengths array to a larger size.
*
* This will resize making the string larger based on the given length.
* If the given length is too large for the buffer, then attempt to set max buffer size (f_array_length_t_size).
*
* @param amount
* A positive number representing how much to increase the size by.
- * @param int8ss
- * The string int8ss array to resize.
+ * @param lengths
+ * The string lengths array to resize.
*
* @return
* F_none on success.
* F_memory_not (with error bit) on out of memory.
* F_parameter (with error bit) if a parameter is invalid.
* F_array_too_large (with error bit) if the new array length is too large.
+ *
+ * Errors (with error bit) from: f_memory_resize().
*/
-#ifndef _di_f_type_int8ss_increase_by_
- extern f_status_t f_type_int8ss_increase_by(const f_array_length_t amount, f_int8ss_t *int8ss);
-#endif // _di_f_type_int8ss_increase_by_
+#ifndef _di_f_type_array_lengths_increase_by_
+ extern f_status_t f_type_array_lengths_increase_by(const f_array_length_t amount, f_array_lengths_t *lengths);
+#endif // _di_f_type_array_lengths_increase_by_
/**
- * Resize the string int8ss array.
+ * Resize the string lengths array.
*
* @param length
* The new size to use.
- * @param int8ss
- * The string int8ss array to adjust.
+ * @param lengths
+ * The string lengths array to adjust.
*
* @return
* F_none on success.
*
* F_memory_not (with error bit) on out of memory.
* F_parameter (with error bit) if a parameter is invalid.
+ *
+ * Errors (with error bit) from: f_memory_resize().
*/
-#ifndef _di_f_type_int8ss_resize_
- extern f_status_t f_type_int8ss_resize(const f_array_length_t length, f_int8ss_t *int8ss);
-#endif // _di_f_type_int8ss_resize_
+#ifndef _di_f_type_array_lengths_resize_
+ extern f_status_t f_type_array_lengths_resize(const f_array_length_t length, f_array_lengths_t *lengths);
+#endif // _di_f_type_array_lengths_resize_
/**
- * Resize the string uint8ss array.
+ * Resize the string lengthss array.
*
* @param length
* The new size to use.
- * @param uint8ss
- * The string uint8ss array to resize.
+ * @param lengthss
+ * The string lengthss array to resize.
*
* @return
* F_none on success.
*
* F_memory_not (with error bit) on out of memory.
* F_parameter (with error bit) if a parameter is invalid.
+ *
+ * Errors (with error bit) from: f_memory_adjust().
+ * Errors (with error bit) from: f_memory_destroy().
*/
-#ifndef _di_f_type_uint8ss_adjust_
- extern f_status_t f_type_uint8ss_adjust(const f_array_length_t length, f_uint8ss_t *uint8ss);
-#endif // _di_f_type_uint8ss_adjust_
+#ifndef _di_f_type_array_lengthss_adjust_
+ extern f_status_t f_type_array_lengthss_adjust(const f_array_length_t length, f_array_lengthss_t *lengthss);
+#endif // _di_f_type_array_lengthss_adjust_
/**
- * Resize the string uint8ss array to a smaller size.
+ * Append the source lengthss onto the destination.
+ *
+ * @param source
+ * The source lengthss to append.
+ * @param destination
+ * The destination ranges the source is appended onto.
+ *
+ * @return
+ * F_none on success.
+ *
+ * F_memory_not (with error bit) on out of memory.
+ * F_parameter (with error bit) if a parameter is invalid.
+ *
+ * Errors (with error bit) from: f_memory_resize().
+ */
+#ifndef _di_f_type_array_lengthss_append_
+ extern f_status_t f_type_array_lengthss_append(const f_array_lengthss_t source, f_array_lengthss_t *destination);
+#endif // _di_f_type_array_lengthss_append_
+
+/**
+ * Resize the string lengthss array.
+ *
+ * @param length
+ * The new size to use.
+ * @param lengthss
+ * The string lengthss array to resize.
+ *
+ * @return
+ * F_none on success.
+ *
+ * F_memory_not (with error bit) on out of memory.
+ * F_parameter (with error bit) if a parameter is invalid.
+ *
+ * Errors (with error bit) from: f_memory_adjust().
+ * Errors (with error bit) from: f_memory_destroy().
+ */
+#ifndef _di_f_type_array_lengthss_adjust_
+ extern f_status_t f_type_array_lengthss_adjust(const f_array_length_t length, f_array_lengthss_t *lengthss);
+#endif // _di_f_type_array_lengthss_adjust_
+
+/**
+ * Resize the string lengthss array to a smaller size.
*
* This will resize making the array smaller based on (size - given length).
* If the given length is too small, then the resize will fail.
*
* @param amount
* A positive number representing how much to decimate the size by.
- * @param uint8ss
- * The string uint8ss array to resize.
+ * @param lengthss
+ * The string lengthss array to resize.
*
* @return
* F_none on success.
*
* F_memory_not (with error bit) on out of memory.
* F_parameter (with error bit) if a parameter is invalid.
+ *
+ * Errors (with error bit) from: f_memory_adjust().
+ * Errors (with error bit) from: f_memory_destroy().
*/
-#ifndef _di_f_type_uint8ss_decimate_by_
- extern f_status_t f_type_uint8ss_decimate_by(const f_array_length_t amount, f_uint8ss_t *uint8ss);
-#endif // _di_f_type_uint8ss_decimate_by_
+#ifndef _di_f_type_array_lengthss_decimate_by_
+ extern f_status_t f_type_array_lengthss_decimate_by(const f_array_length_t amount, f_array_lengthss_t *lengthss);
+#endif // _di_f_type_array_lengthss_decimate_by_
/**
- * Resize the string uint8ss array to a smaller size.
+ * Resize the string lengthss array to a smaller size.
*
* This will resize making the array smaller based on (size - given length).
* If the given length is too small, then the resize will fail.
*
* @param amount
* A positive number representing how much to decrease the size by.
- * @param uint8ss
- * The string uint8ss array to resize.
+ * @param lengthss
+ * The string lengthss array to resize.
*
* @return
* F_none on success.
*
* F_memory_not (with error bit) on out of memory.
* F_parameter (with error bit) if a parameter is invalid.
+ *
+ * Errors (with error bit) from: f_memory_delete().
+ * Errors (with error bit) from: f_memory_resize().
*/
-#ifndef _di_f_type_uint8ss_decrease_by_
- extern f_status_t f_type_uint8ss_decrease_by(const f_array_length_t amount, f_uint8ss_t *uint8ss);
-#endif // _di_f_type_uint8ss_decrease_by_
+#ifndef _di_f_type_array_lengthss_decrease_by_
+ extern f_status_t f_type_array_lengthss_decrease_by(const f_array_length_t amount, f_array_lengthss_t *lengthss);
+#endif // _di_f_type_array_lengthss_decrease_by_
/**
- * Increase the size of the string uint8ss array, but only if necessary.
+ * Increase the size of the string lengthss array, but only if necessary.
*
* If the given length is too large for the buffer, then attempt to set max buffer size (f_array_length_t_size).
* If already set to the maximum buffer size, then the resize will fail.
*
- * @param uint8ss
- * The string uint8ss array to resize.
+ * @param lengthss
+ * The string lengthss array to resize.
*
* @return
* F_none on success.
* F_array_too_large (with error bit) if the new array length is too large.
* F_memory_not (with error bit) on out of memory.
* F_parameter (with error bit) if a parameter is invalid.
+ *
+ * Errors (with error bit) from: f_memory_resize().
*/
-#ifndef _di_f_type_uint8ss_increase_
- extern f_status_t f_type_uint8ss_increase(f_uint8ss_t *uint8ss);
-#endif // _di_f_type_uint8ss_increase_
+#ifndef _di_f_type_array_lengthss_increase_
+ extern f_status_t f_type_array_lengthss_increase(f_array_lengthss_t *lengthss);
+#endif // _di_f_type_array_lengthss_increase_
/**
- * Resize the string uint8ss array to a larger size.
+ * Resize the string lengthss array to a larger size.
*
* This will resize making the string larger based on the given length.
* If the given length is too large for the buffer, then attempt to set max buffer size (f_array_length_t_size).
*
* @param amount
* A positive number representing how much to increase the size by.
- * @param uint8ss
- * The string uint8ss array to resize.
+ * @param lengthss
+ * The string lengthss array to resize.
*
* @return
* F_none on success.
* F_memory_not (with error bit) on out of memory.
* F_parameter (with error bit) if a parameter is invalid.
* F_array_too_large (with error bit) if the new array length is too large.
+ *
+ * Errors (with error bit) from: f_memory_resize().
*/
-#ifndef _di_f_type_uint8ss_increase_by_
- extern f_status_t f_type_uint8ss_increase_by(const f_array_length_t amount, f_uint8ss_t *uint8ss);
-#endif // _di_f_type_uint8ss_increase_by_
+#ifndef _di_f_type_array_lengthss_increase_by_
+ extern f_status_t f_type_array_lengthss_increase_by(const f_array_length_t amount, f_array_lengthss_t *lengthss);
+#endif // _di_f_type_array_lengthss_increase_by_
/**
- * Resize the string uint8ss array.
+ * Resize the string lengthss array.
*
* @param length
* The new size to use.
- * @param uint8ss
- * The string uint8ss array to adjust.
+ * @param lengthss
+ * The string lengthss array to adjust.
*
* @return
* F_none on success.
*
* F_memory_not (with error bit) on out of memory.
* F_parameter (with error bit) if a parameter is invalid.
+ *
+ * Errors (with error bit) from: f_memory_delete().
+ * Errors (with error bit) from: f_memory_resize().
*/
-#ifndef _di_f_type_uint8ss_resize_
- extern f_status_t f_type_uint8ss_resize(const f_array_length_t length, f_uint8ss_t *uint8ss);
-#endif // _di_f_type_uint8ss_resize_
+#ifndef _di_f_type_array_lengthss_resize_
+ extern f_status_t f_type_array_lengthss_resize(const f_array_length_t length, f_array_lengthss_t *lengthss);
+#endif // _di_f_type_array_lengthss_resize_
/**
- * Resize the string int16ss array.
+ * Resize the string int8s array.
*
* @param length
* The new size to use.
- * @param int16ss
- * The string int16ss array to resize.
+ * @param int8s
+ * The string int8s array to resize.
*
* @return
* F_none on success.
*
- * F_memory_not (with error bit) on out of memory.
* F_parameter (with error bit) if a parameter is invalid.
+ *
+ * Errors (with error bit) from: f_memory_adjust().
*/
-#ifndef _di_f_type_int16ss_adjust_
- extern f_status_t f_type_int16ss_adjust(const f_array_length_t length, f_int16ss_t *int16ss);
-#endif // _di_f_type_int16ss_adjust_
+#ifndef _di_f_type_int8s_adjust_
+ extern f_status_t f_type_int8s_adjust(const f_array_length_t length, f_int8s_t *int8s);
+#endif // _di_f_type_int8s_adjust_
/**
- * Resize the string int16ss array to a smaller size.
+ * Append the source int8s onto the destination.
+ *
+ * @param source
+ * The source int8s to append.
+ * @param destination
+ * The destination int8s the source is appended onto.
+ *
+ * @return
+ * F_none on success.
+ *
+ * F_parameter (with error bit) if a parameter is invalid.
+ *
+ * Errors (with error bit) from: f_memory_resize().
+ */
+#ifndef _di_f_type_int8s_append_
+ extern f_status_t f_type_int8s_append(const f_int8s_t source, f_int8s_t *destination);
+#endif // _di_f_type_int8s_append_
+
+/**
+ * Resize the string int8s array to a smaller size.
*
* This will resize making the array smaller based on (size - given length).
* If the given length is too small, then the resize will fail.
- * This will not shrink the size to less than 0.
+ * This will not shrink the size to les than 0.
*
* @param amount
* A positive number representing how much to decimate the size by.
- * @param int16ss
- * The string int16ss array to resize.
+ * @param int8s
+ * The string int8s array to resize.
*
* @return
* F_none on success.
*
* F_memory_not (with error bit) on out of memory.
* F_parameter (with error bit) if a parameter is invalid.
+ *
+ * Errors (with error bit) from: f_memory_adjust().
*/
-#ifndef _di_f_type_int16ss_decimate_by_
- extern f_status_t f_type_int16ss_decimate_by(const f_array_length_t amount, f_int16ss_t *int16ss);
-#endif // _di_f_type_int16ss_decimate_by_
+#ifndef _di_f_type_int8s_decimate_by_
+ extern f_status_t f_type_int8s_decimate_by(const f_array_length_t amount, f_int8s_t *int8s);
+#endif // _di_f_type_int8s_decimate_by_
/**
- * Resize the string int16ss array to a smaller size.
+ * Resize the string int8s array to a smaller size.
*
* This will resize making the array smaller based on (size - given length).
* If the given length is too small, then the resize will fail.
- * This will not shrink the size to less than 0.
+ * This will not shrink the size to les than 0.
*
* @param amount
* A positive number representing how much to decrease the size by.
- * @param int16ss
- * The string int16ss array to resize.
+ * @param int8s
+ * The string int8s array to resize.
*
* @return
* F_none on success.
*
* F_memory_not (with error bit) on out of memory.
* F_parameter (with error bit) if a parameter is invalid.
+ *
+ * Errors (with error bit) from: f_memory_resize().
*/
-#ifndef _di_f_type_int16ss_decrease_by_
- extern f_status_t f_type_int16ss_decrease_by(const f_array_length_t amount, f_int16ss_t *int16ss);
-#endif // _di_f_type_int16ss_decrease_by_
+#ifndef _di_f_type_int8s_decrease_by_
+ extern f_status_t f_type_int8s_decrease_by(const f_array_length_t amount, f_int8s_t *int8s);
+#endif // _di_f_type_int8s_decrease_by_
/**
- * Increase the size of the string int16ss array, but only if necessary.
+ * Increase the size of the string int8s array, but only if necesary.
*
* If the given length is too large for the buffer, then attempt to set max buffer size (f_array_length_t_size).
* If already set to the maximum buffer size, then the resize will fail.
*
- * @param int16ss
- * The string int16ss array to resize.
+ * @param int8s
+ * The string int8s array to resize.
*
* @return
* F_none on success.
* F_array_too_large (with error bit) if the new array length is too large.
* F_memory_not (with error bit) on out of memory.
* F_parameter (with error bit) if a parameter is invalid.
+ *
+ * Errors (with error bit) from: f_memory_resize().
*/
-#ifndef _di_f_type_int16ss_increase_
- extern f_status_t f_type_int16ss_increase(f_int16ss_t *int16ss);
-#endif // _di_f_type_int16ss_increase_
+#ifndef _di_f_type_int8s_increase_
+ extern f_status_t f_type_int8s_increase(f_int8s_t *int8s);
+#endif // _di_f_type_int8s_increase_
/**
- * Resize the string int16ss array to a larger size.
+ * Resize the string int8s array to a larger size.
*
* This will resize making the string larger based on the given length.
* If the given length is too large for the buffer, then attempt to set max buffer size (f_array_length_t_size).
*
* @param amount
* A positive number representing how much to increase the size by.
- * @param int16ss
- * The string int16ss array to resize.
+ * @param int8s
+ * The string int8s array to resize.
*
* @return
* F_none on success.
* F_memory_not (with error bit) on out of memory.
* F_parameter (with error bit) if a parameter is invalid.
* F_array_too_large (with error bit) if the new array length is too large.
+ *
+ * Errors (with error bit) from: f_memory_resize().
*/
-#ifndef _di_f_type_int16ss_increase_by_
- extern f_status_t f_type_int16ss_increase_by(const f_array_length_t amount, f_int16ss_t *int16ss);
-#endif // _di_f_type_int16ss_increase_by_
+#ifndef _di_f_type_int8s_increase_by_
+ extern f_status_t f_type_int8s_increase_by(const f_array_length_t amount, f_int8s_t *int8s);
+#endif // _di_f_type_int8s_increase_by_
/**
- * Resize the string int16ss array.
+ * Resize the string int8s array.
*
* @param length
* The new size to use.
- * @param int16ss
- * The string int16ss array to adjust.
+ * @param int8s
+ * The string int8s array to adjust.
*
* @return
* F_none on success.
*
* F_memory_not (with error bit) on out of memory.
* F_parameter (with error bit) if a parameter is invalid.
+ *
+ * Errors (with error bit) from: f_memory_resize().
*/
-#ifndef _di_f_type_int16ss_resize_
- extern f_status_t f_type_int16ss_resize(const f_array_length_t length, f_int16ss_t *int16ss);
-#endif // _di_f_type_int16ss_resize_
+#ifndef _di_f_type_int8s_resize_
+ extern f_status_t f_type_int8s_resize(const f_array_length_t length, f_int8s_t *int8s);
+#endif // _di_f_type_int8s_resize_
/**
- * Resize the string uint16ss array.
+ * Resize the string int8ss array.
*
* @param length
* The new size to use.
- * @param uint16ss
- * The string uint16ss array to resize.
+ * @param int8ss
+ * The string int8ss array to resize.
*
* @return
* F_none on success.
*
* F_memory_not (with error bit) on out of memory.
* F_parameter (with error bit) if a parameter is invalid.
+ *
+ * Errors (with error bit) from: f_memory_adjust().
+ * Errors (with error bit) from: f_memory_destroy().
*/
-#ifndef _di_f_type_uint16ss_adjust_
- extern f_status_t f_type_uint16ss_adjust(const f_array_length_t length, f_uint16ss_t *uint16ss);
-#endif // _di_f_type_uint16ss_adjust_
+#ifndef _di_f_type_int8ss_adjust_
+ extern f_status_t f_type_int8ss_adjust(const f_array_length_t length, f_int8ss_t *int8ss);
+#endif // _di_f_type_int8ss_adjust_
/**
- * Resize the string uint16ss array to a smaller size.
+ * Append the source int8ss onto the destination.
+ *
+ * @param source
+ * The source int8ss to append.
+ * @param destination
+ * The destination ranges the source is appended onto.
+ *
+ * @return
+ * F_none on success.
+ *
+ * F_memory_not (with error bit) on out of memory.
+ * F_parameter (with error bit) if a parameter is invalid.
+ *
+ * Errors (with error bit) from: f_memory_resize().
+ */
+#ifndef _di_f_type_int8ss_append_
+ extern f_status_t f_type_int8ss_append(const f_int8ss_t source, f_int8ss_t *destination);
+#endif // _di_f_type_int8ss_append_
+
+/**
+ * Resize the string int8ss array.
+ *
+ * @param length
+ * The new size to use.
+ * @param int8ss
+ * The string int8ss array to resize.
+ *
+ * @return
+ * F_none on success.
+ *
+ * F_memory_not (with error bit) on out of memory.
+ * F_parameter (with error bit) if a parameter is invalid.
+ *
+ * Errors (with error bit) from: f_memory_adjust().
+ * Errors (with error bit) from: f_memory_destroy().
+ */
+#ifndef _di_f_type_int8ss_adjust_
+ extern f_status_t f_type_int8ss_adjust(const f_array_length_t length, f_int8ss_t *int8ss);
+#endif // _di_f_type_int8ss_adjust_
+
+/**
+ * Resize the string int8ss array to a smaller size.
*
* This will resize making the array smaller based on (size - given length).
* If the given length is too small, then the resize will fail.
*
* @param amount
* A positive number representing how much to decimate the size by.
- * @param uint16ss
- * The string uint16ss array to resize.
+ * @param int8ss
+ * The string int8ss array to resize.
*
* @return
* F_none on success.
*
* F_memory_not (with error bit) on out of memory.
* F_parameter (with error bit) if a parameter is invalid.
+ *
+ * Errors (with error bit) from: f_memory_adjust().
+ * Errors (with error bit) from: f_memory_destroy().
*/
-#ifndef _di_f_type_uint16ss_decimate_by_
- extern f_status_t f_type_uint16ss_decimate_by(const f_array_length_t amount, f_uint16ss_t *uint16ss);
-#endif // _di_f_type_uint16ss_decimate_by_
+#ifndef _di_f_type_int8ss_decimate_by_
+ extern f_status_t f_type_int8ss_decimate_by(const f_array_length_t amount, f_int8ss_t *int8ss);
+#endif // _di_f_type_int8ss_decimate_by_
/**
- * Resize the string uint16ss array to a smaller size.
+ * Resize the string int8ss array to a smaller size.
*
* This will resize making the array smaller based on (size - given length).
* If the given length is too small, then the resize will fail.
*
* @param amount
* A positive number representing how much to decrease the size by.
- * @param uint16ss
- * The string uint16ss array to resize.
+ * @param int8ss
+ * The string int8ss array to resize.
*
* @return
* F_none on success.
*
* F_memory_not (with error bit) on out of memory.
* F_parameter (with error bit) if a parameter is invalid.
+ *
+ * Errors (with error bit) from: f_memory_delete().
+ * Errors (with error bit) from: f_memory_resize().
*/
-#ifndef _di_f_type_uint16ss_decrease_by_
- extern f_status_t f_type_uint16ss_decrease_by(const f_array_length_t amount, f_uint16ss_t *uint16ss);
-#endif // _di_f_type_uint16ss_decrease_by_
+#ifndef _di_f_type_int8ss_decrease_by_
+ extern f_status_t f_type_int8ss_decrease_by(const f_array_length_t amount, f_int8ss_t *int8ss);
+#endif // _di_f_type_int8ss_decrease_by_
/**
- * Increase the size of the string uint16ss array, but only if necessary.
+ * Increase the size of the string int8ss array, but only if necessary.
*
* If the given length is too large for the buffer, then attempt to set max buffer size (f_array_length_t_size).
* If already set to the maximum buffer size, then the resize will fail.
*
- * @param uint16ss
- * The string uint16ss array to resize.
+ * @param int8ss
+ * The string int8ss array to resize.
*
* @return
* F_none on success.
* F_array_too_large (with error bit) if the new array length is too large.
* F_memory_not (with error bit) on out of memory.
* F_parameter (with error bit) if a parameter is invalid.
+ *
+ * Errors (with error bit) from: f_memory_resize().
*/
-#ifndef _di_f_type_uint16ss_increase_
- extern f_status_t f_type_uint16ss_increase(f_uint16ss_t *uint16ss);
-#endif // _di_f_type_uint16ss_increase_
+#ifndef _di_f_type_int8ss_increase_
+ extern f_status_t f_type_int8ss_increase(f_int8ss_t *int8ss);
+#endif // _di_f_type_int8ss_increase_
/**
- * Resize the string uint16ss array to a larger size.
+ * Resize the string int8ss array to a larger size.
*
* This will resize making the string larger based on the given length.
* If the given length is too large for the buffer, then attempt to set max buffer size (f_array_length_t_size).
*
* @param amount
* A positive number representing how much to increase the size by.
- * @param uint16ss
- * The string uint16ss array to resize.
+ * @param int8ss
+ * The string int8ss array to resize.
*
* @return
* F_none on success.
* F_memory_not (with error bit) on out of memory.
* F_parameter (with error bit) if a parameter is invalid.
* F_array_too_large (with error bit) if the new array length is too large.
+ *
+ * Errors (with error bit) from: f_memory_resize().
*/
-#ifndef _di_f_type_uint16ss_increase_by_
- extern f_status_t f_type_uint16ss_increase_by(const f_array_length_t amount, f_uint16ss_t *uint16ss);
-#endif // _di_f_type_uint16ss_increase_by_
+#ifndef _di_f_type_int8ss_increase_by_
+ extern f_status_t f_type_int8ss_increase_by(const f_array_length_t amount, f_int8ss_t *int8ss);
+#endif // _di_f_type_int8ss_increase_by_
/**
- * Resize the string uint16ss array.
+ * Resize the string int8ss array.
*
* @param length
* The new size to use.
- * @param uint16ss
- * The string uint16ss array to adjust.
+ * @param int8ss
+ * The string int8ss array to adjust.
*
* @return
* F_none on success.
*
* F_memory_not (with error bit) on out of memory.
* F_parameter (with error bit) if a parameter is invalid.
+ *
+ * Errors (with error bit) from: f_memory_delete().
+ * Errors (with error bit) from: f_memory_resize().
*/
-#ifndef _di_f_type_uint16ss_resize_
- extern f_status_t f_type_uint16ss_resize(const f_array_length_t length, f_uint16ss_t *uint16ss);
-#endif // _di_f_type_uint16ss_resize_
-
+#ifndef _di_f_type_int8ss_resize_
+ extern f_status_t f_type_int8ss_resize(const f_array_length_t length, f_int8ss_t *int8ss);
+#endif // _di_f_type_int8ss_resize_
/**
- * Resize the string int32ss array.
+ * Resize the string uint8s array.
*
* @param length
* The new size to use.
- * @param int32ss
- * The string int32ss array to resize.
+ * @param uint8s
+ * The string uint8s array to resize.
*
* @return
* F_none on success.
*
- * F_memory_not (with error bit) on out of memory.
* F_parameter (with error bit) if a parameter is invalid.
+ *
+ * Errors (with error bit) from: f_memory_adjust().
*/
-#ifndef _di_f_type_int32ss_adjust_
- extern f_status_t f_type_int32ss_adjust(const f_array_length_t length, f_int32ss_t *int32ss);
-#endif // _di_f_type_int32ss_adjust_
+#ifndef _di_f_type_uint8s_adjust_
+ extern f_status_t f_type_uint8s_adjust(const f_array_length_t length, f_uint8s_t *uint8s);
+#endif // _di_f_type_uint8s_adjust_
/**
- * Resize the string int32ss array to a smaller size.
+ * Append the source uint8s onto the destination.
+ *
+ * @param source
+ * The source uint8s to append.
+ * @param destination
+ * The destination uint8s the source is appended onto.
+ *
+ * @return
+ * F_none on success.
+ *
+ * F_parameter (with error bit) if a parameter is invalid.
+ *
+ * Errors (with error bit) from: f_memory_resize().
+ */
+#ifndef _di_f_type_uint8s_append_
+ extern f_status_t f_type_uint8s_append(const f_uint8s_t source, f_uint8s_t *destination);
+#endif // _di_f_type_uint8s_append_
+
+/**
+ * Resize the string uint8s array to a smaller size.
*
* This will resize making the array smaller based on (size - given length).
* If the given length is too small, then the resize will fail.
- * This will not shrink the size to less than 0.
+ * This will not shrink the size to les than 0.
*
* @param amount
* A positive number representing how much to decimate the size by.
- * @param int32ss
- * The string int32ss array to resize.
+ * @param uint8s
+ * The string uint8s array to resize.
*
* @return
* F_none on success.
*
* F_memory_not (with error bit) on out of memory.
* F_parameter (with error bit) if a parameter is invalid.
+ *
+ * Errors (with error bit) from: f_memory_adjust().
*/
-#ifndef _di_f_type_int32ss_decimate_by_
- extern f_status_t f_type_int32ss_decimate_by(const f_array_length_t amount, f_int32ss_t *int32ss);
-#endif // _di_f_type_int32ss_decimate_by_
+#ifndef _di_f_type_uint8s_decimate_by_
+ extern f_status_t f_type_uint8s_decimate_by(const f_array_length_t amount, f_uint8s_t *uint8s);
+#endif // _di_f_type_uint8s_decimate_by_
/**
- * Resize the string int32ss array to a smaller size.
+ * Resize the string uint8s array to a smaller size.
*
* This will resize making the array smaller based on (size - given length).
* If the given length is too small, then the resize will fail.
- * This will not shrink the size to less than 0.
+ * This will not shrink the size to les than 0.
*
* @param amount
* A positive number representing how much to decrease the size by.
- * @param int32ss
- * The string int32ss array to resize.
+ * @param uint8s
+ * The string uint8s array to resize.
*
* @return
* F_none on success.
*
* F_memory_not (with error bit) on out of memory.
* F_parameter (with error bit) if a parameter is invalid.
+ *
+ * Errors (with error bit) from: f_memory_resize().
*/
-#ifndef _di_f_type_int32ss_decrease_by_
- extern f_status_t f_type_int32ss_decrease_by(const f_array_length_t amount, f_int32ss_t *int32ss);
-#endif // _di_f_type_int32ss_decrease_by_
+#ifndef _di_f_type_uint8s_decrease_by_
+ extern f_status_t f_type_uint8s_decrease_by(const f_array_length_t amount, f_uint8s_t *uint8s);
+#endif // _di_f_type_uint8s_decrease_by_
/**
- * Increase the size of the string int32ss array, but only if necessary.
+ * Increase the size of the string uint8s array, but only if necesary.
*
* If the given length is too large for the buffer, then attempt to set max buffer size (f_array_length_t_size).
* If already set to the maximum buffer size, then the resize will fail.
*
- * @param int32ss
- * The string int32ss array to resize.
+ * @param uint8s
+ * The string uint8s array to resize.
*
* @return
* F_none on success.
* F_array_too_large (with error bit) if the new array length is too large.
* F_memory_not (with error bit) on out of memory.
* F_parameter (with error bit) if a parameter is invalid.
+ *
+ * Errors (with error bit) from: f_memory_resize().
*/
-#ifndef _di_f_type_int32ss_increase_
- extern f_status_t f_type_int32ss_increase(f_int32ss_t *int32ss);
-#endif // _di_f_type_int32ss_increase_
+#ifndef _di_f_type_uint8s_increase_
+ extern f_status_t f_type_uint8s_increase(f_uint8s_t *uint8s);
+#endif // _di_f_type_uint8s_increase_
/**
- * Resize the string int32ss array to a larger size.
+ * Resize the string uint8s array to a larger size.
*
* This will resize making the string larger based on the given length.
* If the given length is too large for the buffer, then attempt to set max buffer size (f_array_length_t_size).
*
* @param amount
* A positive number representing how much to increase the size by.
- * @param int32ss
- * The string int32ss array to resize.
+ * @param uint8s
+ * The string uint8s array to resize.
*
* @return
* F_none on success.
* F_memory_not (with error bit) on out of memory.
* F_parameter (with error bit) if a parameter is invalid.
* F_array_too_large (with error bit) if the new array length is too large.
+ *
+ * Errors (with error bit) from: f_memory_resize().
*/
-#ifndef _di_f_type_int32ss_increase_by_
- extern f_status_t f_type_int32ss_increase_by(const f_array_length_t amount, f_int32ss_t *int32ss);
-#endif // _di_f_type_int32ss_increase_by_
+#ifndef _di_f_type_uint8s_increase_by_
+ extern f_status_t f_type_uint8s_increase_by(const f_array_length_t amount, f_uint8s_t *uint8s);
+#endif // _di_f_type_uint8s_increase_by_
/**
- * Resize the string int32ss array.
+ * Resize the string uint8s array.
*
* @param length
* The new size to use.
- * @param int32ss
- * The string int32ss array to adjust.
+ * @param uint8s
+ * The string uint8s array to adjust.
*
* @return
* F_none on success.
*
* F_memory_not (with error bit) on out of memory.
* F_parameter (with error bit) if a parameter is invalid.
+ *
+ * Errors (with error bit) from: f_memory_resize().
*/
-#ifndef _di_f_type_int32ss_resize_
- extern f_status_t f_type_int32ss_resize(const f_array_length_t length, f_int32ss_t *int32ss);
-#endif // _di_f_type_int32ss_resize_
-
+#ifndef _di_f_type_uint8s_resize_
+ extern f_status_t f_type_uint8s_resize(const f_array_length_t length, f_uint8s_t *uint8s);
+#endif // _di_f_type_uint8s_resize_
/**
- * Resize the string uint32ss array.
+ * Resize the string uint8ss array.
*
* @param length
* The new size to use.
- * @param uint32ss
- * The string uint32ss array to resize.
+ * @param uint8ss
+ * The string uint8ss array to resize.
*
* @return
* F_none on success.
*
* F_memory_not (with error bit) on out of memory.
* F_parameter (with error bit) if a parameter is invalid.
+ *
+ * Errors (with error bit) from: f_memory_adjust().
+ * Errors (with error bit) from: f_memory_destroy().
*/
-#ifndef _di_f_type_uint32ss_adjust_
- extern f_status_t f_type_uint32ss_adjust(const f_array_length_t length, f_uint32ss_t *uint32ss);
-#endif // _di_f_type_uint32ss_adjust_
+#ifndef _di_f_type_uint8ss_adjust_
+ extern f_status_t f_type_uint8ss_adjust(const f_array_length_t length, f_uint8ss_t *uint8ss);
+#endif // _di_f_type_uint8ss_adjust_
/**
- * Resize the string uint32ss array to a smaller size.
+ * Append the source uint8ss onto the destination.
*
- * This will resize making the array smaller based on (size - given length).
- * If the given length is too small, then the resize will fail.
- * This will not shrink the size to less than 0.
- *
- * @param amount
- * A positive number representing how much to decimate the size by.
- * @param uint32ss
- * The string uint32ss array to resize.
+ * @param source
+ * The source uint8ss to append.
+ * @param destination
+ * The destination ranges the source is appended onto.
*
* @return
* F_none on success.
*
* F_memory_not (with error bit) on out of memory.
* F_parameter (with error bit) if a parameter is invalid.
+ *
+ * Errors (with error bit) from: f_memory_resize().
+ */
+#ifndef _di_f_type_uint8ss_append_
+ extern f_status_t f_type_uint8ss_append(const f_uint8ss_t source, f_uint8ss_t *destination);
+#endif // _di_f_type_uint8ss_append_
+
+/**
+ * Resize the string uint8ss array.
+ *
+ * @param length
+ * The new size to use.
+ * @param uint8ss
+ * The string uint8ss array to resize.
+ *
+ * @return
+ * F_none on success.
+ *
+ * F_memory_not (with error bit) on out of memory.
+ * F_parameter (with error bit) if a parameter is invalid.
+ *
+ * Errors (with error bit) from: f_memory_adjust().
+ * Errors (with error bit) from: f_memory_destroy().
+ */
+#ifndef _di_f_type_uint8ss_adjust_
+ extern f_status_t f_type_uint8ss_adjust(const f_array_length_t length, f_uint8ss_t *uint8ss);
+#endif // _di_f_type_uint8ss_adjust_
+
+/**
+ * Resize the string uint8ss array to a smaller size.
+ *
+ * This will resize making the array smaller based on (size - given length).
+ * If the given length is too small, then the resize will fail.
+ * This will not shrink the size to less than 0.
+ *
+ * @param amount
+ * A positive number representing how much to decimate the size by.
+ * @param uint8ss
+ * The string uint8ss array to resize.
+ *
+ * @return
+ * F_none on success.
+ *
+ * F_memory_not (with error bit) on out of memory.
+ * F_parameter (with error bit) if a parameter is invalid.
+ *
+ * Errors (with error bit) from: f_memory_adjust().
+ * Errors (with error bit) from: f_memory_destroy().
+ */
+#ifndef _di_f_type_uint8ss_decimate_by_
+ extern f_status_t f_type_uint8ss_decimate_by(const f_array_length_t amount, f_uint8ss_t *uint8ss);
+#endif // _di_f_type_uint8ss_decimate_by_
+
+/**
+ * Resize the string uint8ss array to a smaller size.
+ *
+ * This will resize making the array smaller based on (size - given length).
+ * If the given length is too small, then the resize will fail.
+ * This will not shrink the size to less than 0.
+ *
+ * @param amount
+ * A positive number representing how much to decrease the size by.
+ * @param uint8ss
+ * The string uint8ss array to resize.
+ *
+ * @return
+ * F_none on success.
+ *
+ * F_memory_not (with error bit) on out of memory.
+ * F_parameter (with error bit) if a parameter is invalid.
+ *
+ * Errors (with error bit) from: f_memory_delete().
+ * Errors (with error bit) from: f_memory_resize().
+ */
+#ifndef _di_f_type_uint8ss_decrease_by_
+ extern f_status_t f_type_uint8ss_decrease_by(const f_array_length_t amount, f_uint8ss_t *uint8ss);
+#endif // _di_f_type_uint8ss_decrease_by_
+
+/**
+ * Increase the size of the string uint8ss array, but only if necessary.
+ *
+ * If the given length is too large for the buffer, then attempt to set max buffer size (f_array_length_t_size).
+ * If already set to the maximum buffer size, then the resize will fail.
+ *
+ * @param uint8ss
+ * The string uint8ss array to resize.
+ *
+ * @return
+ * F_none on success.
+ * F_data_not on success, but there is no reason to increase size (used + 1 <= size).
+ *
+ * F_array_too_large (with error bit) if the new array length is too large.
+ * F_memory_not (with error bit) on out of memory.
+ * F_parameter (with error bit) if a parameter is invalid.
+ *
+ * Errors (with error bit) from: f_memory_resize().
+ */
+#ifndef _di_f_type_uint8ss_increase_
+ extern f_status_t f_type_uint8ss_increase(f_uint8ss_t *uint8ss);
+#endif // _di_f_type_uint8ss_increase_
+
+/**
+ * Resize the string uint8ss array to a larger size.
+ *
+ * This will resize making the string larger based on the given length.
+ * If the given length is too large for the buffer, then attempt to set max buffer size (f_array_length_t_size).
+ * If already set to the maximum buffer size, then the resize will fail.
+ *
+ * @param amount
+ * A positive number representing how much to increase the size by.
+ * @param uint8ss
+ * The string uint8ss array to resize.
+ *
+ * @return
+ * F_none on success.
+ * F_data_not on success, but there is no reason to increase size (used + amount <= size).
+ *
+ * F_memory_not (with error bit) on out of memory.
+ * F_parameter (with error bit) if a parameter is invalid.
+ * F_array_too_large (with error bit) if the new array length is too large.
+ *
+ * Errors (with error bit) from: f_memory_resize().
+ */
+#ifndef _di_f_type_uint8ss_increase_by_
+ extern f_status_t f_type_uint8ss_increase_by(const f_array_length_t amount, f_uint8ss_t *uint8ss);
+#endif // _di_f_type_uint8ss_increase_by_
+
+/**
+ * Resize the string uint8ss array.
+ *
+ * @param length
+ * The new size to use.
+ * @param uint8ss
+ * The string uint8ss array to adjust.
+ *
+ * @return
+ * F_none on success.
+ *
+ * F_memory_not (with error bit) on out of memory.
+ * F_parameter (with error bit) if a parameter is invalid.
+ *
+ * Errors (with error bit) from: f_memory_delete().
+ * Errors (with error bit) from: f_memory_resize().
+ */
+#ifndef _di_f_type_uint8ss_resize_
+ extern f_status_t f_type_uint8ss_resize(const f_array_length_t length, f_uint8ss_t *uint8ss);
+#endif // _di_f_type_uint8ss_resize_
+
+/**
+ * Resize the string int16s array.
+ *
+ * @param length
+ * The new size to use.
+ * @param int16s
+ * The string int16s array to resize.
+ *
+ * @return
+ * F_none on success.
+ *
+ * F_parameter (with error bit) if a parameter is invalid.
+ *
+ * Errors (with error bit) from: f_memory_adjust().
+ */
+#ifndef _di_f_type_int16s_adjust_
+ extern f_status_t f_type_int16s_adjust(const f_array_length_t length, f_int16s_t *int16s);
+#endif // _di_f_type_int16s_adjust_
+
+/**
+ * Append the source int16s onto the destination.
+ *
+ * @param source
+ * The source int16s to append.
+ * @param destination
+ * The destination int16s the source is appended onto.
+ *
+ * @return
+ * F_none on success.
+ *
+ * F_parameter (with error bit) if a parameter is invalid.
+ *
+ * Errors (with error bit) from: f_memory_resize().
+ */
+#ifndef _di_f_type_int16s_append_
+ extern f_status_t f_type_int16s_append(const f_int16s_t source, f_int16s_t *destination);
+#endif // _di_f_type_int16s_append_
+
+/**
+ * Resize the string int16s array to a smaller size.
+ *
+ * This will resize making the array smaller based on (size - given length).
+ * If the given length is too small, then the resize will fail.
+ * This will not shrink the size to les than 0.
+ *
+ * @param amount
+ * A positive number representing how much to decimate the size by.
+ * @param int16s
+ * The string int16s array to resize.
+ *
+ * @return
+ * F_none on success.
+ *
+ * F_memory_not (with error bit) on out of memory.
+ * F_parameter (with error bit) if a parameter is invalid.
+ *
+ * Errors (with error bit) from: f_memory_adjust().
+ */
+#ifndef _di_f_type_int16s_decimate_by_
+ extern f_status_t f_type_int16s_decimate_by(const f_array_length_t amount, f_int16s_t *int16s);
+#endif // _di_f_type_int16s_decimate_by_
+
+/**
+ * Resize the string int16s array to a smaller size.
+ *
+ * This will resize making the array smaller based on (size - given length).
+ * If the given length is too small, then the resize will fail.
+ * This will not shrink the size to les than 0.
+ *
+ * @param amount
+ * A positive number representing how much to decrease the size by.
+ * @param int16s
+ * The string int16s array to resize.
+ *
+ * @return
+ * F_none on success.
+ *
+ * F_memory_not (with error bit) on out of memory.
+ * F_parameter (with error bit) if a parameter is invalid.
+ *
+ * Errors (with error bit) from: f_memory_resize().
+ */
+#ifndef _di_f_type_int16s_decrease_by_
+ extern f_status_t f_type_int16s_decrease_by(const f_array_length_t amount, f_int16s_t *int16s);
+#endif // _di_f_type_int16s_decrease_by_
+
+/**
+ * Increase the size of the string int16s array, but only if necesary.
+ *
+ * If the given length is too large for the buffer, then attempt to set max buffer size (f_array_length_t_size).
+ * If already set to the maximum buffer size, then the resize will fail.
+ *
+ * @param int16s
+ * The string int16s array to resize.
+ *
+ * @return
+ * F_none on success.
+ * F_data_not on success, but there is no reason to increase size (used + 1 <= size).
+ *
+ * F_array_too_large (with error bit) if the new array length is too large.
+ * F_memory_not (with error bit) on out of memory.
+ * F_parameter (with error bit) if a parameter is invalid.
+ *
+ * Errors (with error bit) from: f_memory_resize().
+ */
+#ifndef _di_f_type_int16s_increase_
+ extern f_status_t f_type_int16s_increase(f_int16s_t *int16s);
+#endif // _di_f_type_int16s_increase_
+
+/**
+ * Resize the string int16s array to a larger size.
+ *
+ * This will resize making the string larger based on the given length.
+ * If the given length is too large for the buffer, then attempt to set max buffer size (f_array_length_t_size).
+ * If already set to the maximum buffer size, then the resize will fail.
+ *
+ * @param amount
+ * A positive number representing how much to increase the size by.
+ * @param int16s
+ * The string int16s array to resize.
+ *
+ * @return
+ * F_none on success.
+ * F_data_not on success, but there is no reason to increase size (used + amount <= size).
+ *
+ * F_memory_not (with error bit) on out of memory.
+ * F_parameter (with error bit) if a parameter is invalid.
+ * F_array_too_large (with error bit) if the new array length is too large.
+ *
+ * Errors (with error bit) from: f_memory_resize().
+ */
+#ifndef _di_f_type_int16s_increase_by_
+ extern f_status_t f_type_int16s_increase_by(const f_array_length_t amount, f_int16s_t *int16s);
+#endif // _di_f_type_int16s_increase_by_
+
+/**
+ * Resize the string int16s array.
+ *
+ * @param length
+ * The new size to use.
+ * @param int16s
+ * The string int16s array to adjust.
+ *
+ * @return
+ * F_none on success.
+ *
+ * F_memory_not (with error bit) on out of memory.
+ * F_parameter (with error bit) if a parameter is invalid.
+ *
+ * Errors (with error bit) from: f_memory_resize().
+ */
+#ifndef _di_f_type_int16s_resize_
+ extern f_status_t f_type_int16s_resize(const f_array_length_t length, f_int16s_t *int16s);
+#endif // _di_f_type_int16s_resize_
+
+/**
+ * Resize the string int16ss array.
+ *
+ * @param length
+ * The new size to use.
+ * @param int16ss
+ * The string int16ss array to resize.
+ *
+ * @return
+ * F_none on success.
+ *
+ * F_memory_not (with error bit) on out of memory.
+ * F_parameter (with error bit) if a parameter is invalid.
+ *
+ * Errors (with error bit) from: f_memory_adjust().
+ * Errors (with error bit) from: f_memory_destroy().
+ */
+#ifndef _di_f_type_int16ss_adjust_
+ extern f_status_t f_type_int16ss_adjust(const f_array_length_t length, f_int16ss_t *int16ss);
+#endif // _di_f_type_int16ss_adjust_
+
+/**
+ * Append the source int16ss onto the destination.
+ *
+ * @param source
+ * The source int16ss to append.
+ * @param destination
+ * The destination ranges the source is appended onto.
+ *
+ * @return
+ * F_none on success.
+ *
+ * F_memory_not (with error bit) on out of memory.
+ * F_parameter (with error bit) if a parameter is invalid.
+ *
+ * Errors (with error bit) from: f_memory_resize().
+ */
+#ifndef _di_f_type_int16ss_append_
+ extern f_status_t f_type_int16ss_append(const f_int16ss_t source, f_int16ss_t *destination);
+#endif // _di_f_type_int16ss_append_
+
+/**
+ * Resize the string int16ss array.
+ *
+ * @param length
+ * The new size to use.
+ * @param int16ss
+ * The string int16ss array to resize.
+ *
+ * @return
+ * F_none on success.
+ *
+ * F_memory_not (with error bit) on out of memory.
+ * F_parameter (with error bit) if a parameter is invalid.
+ *
+ * Errors (with error bit) from: f_memory_adjust().
+ * Errors (with error bit) from: f_memory_destroy().
+ */
+#ifndef _di_f_type_int16ss_adjust_
+ extern f_status_t f_type_int16ss_adjust(const f_array_length_t length, f_int16ss_t *int16ss);
+#endif // _di_f_type_int16ss_adjust_
+
+/**
+ * Resize the string int16ss array to a smaller size.
+ *
+ * This will resize making the array smaller based on (size - given length).
+ * If the given length is too small, then the resize will fail.
+ * This will not shrink the size to less than 0.
+ *
+ * @param amount
+ * A positive number representing how much to decimate the size by.
+ * @param int16ss
+ * The string int16ss array to resize.
+ *
+ * @return
+ * F_none on success.
+ *
+ * F_memory_not (with error bit) on out of memory.
+ * F_parameter (with error bit) if a parameter is invalid.
+ *
+ * Errors (with error bit) from: f_memory_adjust().
+ * Errors (with error bit) from: f_memory_destroy().
+ */
+#ifndef _di_f_type_int16ss_decimate_by_
+ extern f_status_t f_type_int16ss_decimate_by(const f_array_length_t amount, f_int16ss_t *int16ss);
+#endif // _di_f_type_int16ss_decimate_by_
+
+/**
+ * Resize the string int16ss array to a smaller size.
+ *
+ * This will resize making the array smaller based on (size - given length).
+ * If the given length is too small, then the resize will fail.
+ * This will not shrink the size to less than 0.
+ *
+ * @param amount
+ * A positive number representing how much to decrease the size by.
+ * @param int16ss
+ * The string int16ss array to resize.
+ *
+ * @return
+ * F_none on success.
+ *
+ * F_memory_not (with error bit) on out of memory.
+ * F_parameter (with error bit) if a parameter is invalid.
+ *
+ * Errors (with error bit) from: f_memory_delete().
+ * Errors (with error bit) from: f_memory_resize().
+ */
+#ifndef _di_f_type_int16ss_decrease_by_
+ extern f_status_t f_type_int16ss_decrease_by(const f_array_length_t amount, f_int16ss_t *int16ss);
+#endif // _di_f_type_int16ss_decrease_by_
+
+/**
+ * Increase the size of the string int16ss array, but only if necessary.
+ *
+ * If the given length is too large for the buffer, then attempt to set max buffer size (f_array_length_t_size).
+ * If already set to the maximum buffer size, then the resize will fail.
+ *
+ * @param int16ss
+ * The string int16ss array to resize.
+ *
+ * @return
+ * F_none on success.
+ * F_data_not on success, but there is no reason to increase size (used + 1 <= size).
+ *
+ * F_array_too_large (with error bit) if the new array length is too large.
+ * F_memory_not (with error bit) on out of memory.
+ * F_parameter (with error bit) if a parameter is invalid.
+ *
+ * Errors (with error bit) from: f_memory_resize().
+ */
+#ifndef _di_f_type_int16ss_increase_
+ extern f_status_t f_type_int16ss_increase(f_int16ss_t *int16ss);
+#endif // _di_f_type_int16ss_increase_
+
+/**
+ * Resize the string int16ss array to a larger size.
+ *
+ * This will resize making the string larger based on the given length.
+ * If the given length is too large for the buffer, then attempt to set max buffer size (f_array_length_t_size).
+ * If already set to the maximum buffer size, then the resize will fail.
+ *
+ * @param amount
+ * A positive number representing how much to increase the size by.
+ * @param int16ss
+ * The string int16ss array to resize.
+ *
+ * @return
+ * F_none on success.
+ * F_data_not on success, but there is no reason to increase size (used + amount <= size).
+ *
+ * F_memory_not (with error bit) on out of memory.
+ * F_parameter (with error bit) if a parameter is invalid.
+ * F_array_too_large (with error bit) if the new array length is too large.
+ *
+ * Errors (with error bit) from: f_memory_resize().
+ */
+#ifndef _di_f_type_int16ss_increase_by_
+ extern f_status_t f_type_int16ss_increase_by(const f_array_length_t amount, f_int16ss_t *int16ss);
+#endif // _di_f_type_int16ss_increase_by_
+
+/**
+ * Resize the string int16ss array.
+ *
+ * @param length
+ * The new size to use.
+ * @param int16ss
+ * The string int16ss array to adjust.
+ *
+ * @return
+ * F_none on success.
+ *
+ * F_memory_not (with error bit) on out of memory.
+ * F_parameter (with error bit) if a parameter is invalid.
+ *
+ * Errors (with error bit) from: f_memory_delete().
+ * Errors (with error bit) from: f_memory_resize().
+ */
+#ifndef _di_f_type_int16ss_resize_
+ extern f_status_t f_type_int16ss_resize(const f_array_length_t length, f_int16ss_t *int16ss);
+#endif // _di_f_type_int16ss_resize_
+
+/**
+ * Resize the string uint16s array.
+ *
+ * @param length
+ * The new size to use.
+ * @param uint16s
+ * The string uint16s array to resize.
+ *
+ * @return
+ * F_none on success.
+ *
+ * F_parameter (with error bit) if a parameter is invalid.
+ *
+ * Errors (with error bit) from: f_memory_adjust().
+ */
+#ifndef _di_f_type_uint16s_adjust_
+ extern f_status_t f_type_uint16s_adjust(const f_array_length_t length, f_uint16s_t *uint16s);
+#endif // _di_f_type_uint16s_adjust_
+
+/**
+ * Append the source uint16s onto the destination.
+ *
+ * @param source
+ * The source uint16s to append.
+ * @param destination
+ * The destination uint16s the source is appended onto.
+ *
+ * @return
+ * F_none on success.
+ *
+ * F_parameter (with error bit) if a parameter is invalid.
+ *
+ * Errors (with error bit) from: f_memory_resize().
+ */
+#ifndef _di_f_type_uint16s_append_
+ extern f_status_t f_type_uint16s_append(const f_uint16s_t source, f_uint16s_t *destination);
+#endif // _di_f_type_uint16s_append_
+
+/**
+ * Resize the string uint16s array to a smaller size.
+ *
+ * This will resize making the array smaller based on (size - given length).
+ * If the given length is too small, then the resize will fail.
+ * This will not shrink the size to les than 0.
+ *
+ * @param amount
+ * A positive number representing how much to decimate the size by.
+ * @param uint16s
+ * The string uint16s array to resize.
+ *
+ * @return
+ * F_none on success.
+ *
+ * F_memory_not (with error bit) on out of memory.
+ * F_parameter (with error bit) if a parameter is invalid.
+ *
+ * Errors (with error bit) from: f_memory_adjust().
+ */
+#ifndef _di_f_type_uint16s_decimate_by_
+ extern f_status_t f_type_uint16s_decimate_by(const f_array_length_t amount, f_uint16s_t *uint16s);
+#endif // _di_f_type_uint16s_decimate_by_
+
+/**
+ * Resize the string uint16s array to a smaller size.
+ *
+ * This will resize making the array smaller based on (size - given length).
+ * If the given length is too small, then the resize will fail.
+ * This will not shrink the size to les than 0.
+ *
+ * @param amount
+ * A positive number representing how much to decrease the size by.
+ * @param uint16s
+ * The string uint16s array to resize.
+ *
+ * @return
+ * F_none on success.
+ *
+ * F_memory_not (with error bit) on out of memory.
+ * F_parameter (with error bit) if a parameter is invalid.
+ *
+ * Errors (with error bit) from: f_memory_resize().
+ */
+#ifndef _di_f_type_uint16s_decrease_by_
+ extern f_status_t f_type_uint16s_decrease_by(const f_array_length_t amount, f_uint16s_t *uint16s);
+#endif // _di_f_type_uint16s_decrease_by_
+
+/**
+ * Increase the size of the string uint16s array, but only if necesary.
+ *
+ * If the given length is too large for the buffer, then attempt to set max buffer size (f_array_length_t_size).
+ * If already set to the maximum buffer size, then the resize will fail.
+ *
+ * @param uint16s
+ * The string uint16s array to resize.
+ *
+ * @return
+ * F_none on success.
+ * F_data_not on success, but there is no reason to increase size (used + 1 <= size).
+ *
+ * F_array_too_large (with error bit) if the new array length is too large.
+ * F_memory_not (with error bit) on out of memory.
+ * F_parameter (with error bit) if a parameter is invalid.
+ *
+ * Errors (with error bit) from: f_memory_resize().
+ */
+#ifndef _di_f_type_uint16s_increase_
+ extern f_status_t f_type_uint16s_increase(f_uint16s_t *uint16s);
+#endif // _di_f_type_uint16s_increase_
+
+/**
+ * Resize the string uint16s array to a larger size.
+ *
+ * This will resize making the string larger based on the given length.
+ * If the given length is too large for the buffer, then attempt to set max buffer size (f_array_length_t_size).
+ * If already set to the maximum buffer size, then the resize will fail.
+ *
+ * @param amount
+ * A positive number representing how much to increase the size by.
+ * @param uint16s
+ * The string uint16s array to resize.
+ *
+ * @return
+ * F_none on success.
+ * F_data_not on success, but there is no reason to increase size (used + amount <= size).
+ *
+ * F_memory_not (with error bit) on out of memory.
+ * F_parameter (with error bit) if a parameter is invalid.
+ * F_array_too_large (with error bit) if the new array length is too large.
+ *
+ * Errors (with error bit) from: f_memory_resize().
+ */
+#ifndef _di_f_type_uint16s_increase_by_
+ extern f_status_t f_type_uint16s_increase_by(const f_array_length_t amount, f_uint16s_t *uint16s);
+#endif // _di_f_type_uint16s_increase_by_
+
+/**
+ * Resize the string uint16s array.
+ *
+ * @param length
+ * The new size to use.
+ * @param uint16s
+ * The string uint16s array to adjust.
+ *
+ * @return
+ * F_none on success.
+ *
+ * F_memory_not (with error bit) on out of memory.
+ * F_parameter (with error bit) if a parameter is invalid.
+ *
+ * Errors (with error bit) from: f_memory_resize().
+ */
+#ifndef _di_f_type_uint16s_resize_
+ extern f_status_t f_type_uint16s_resize(const f_array_length_t length, f_uint16s_t *uint16s);
+#endif // _di_f_type_uint16s_resize_
+
+/**
+ * Resize the string uint16ss array.
+ *
+ * @param length
+ * The new size to use.
+ * @param uint16ss
+ * The string uint16ss array to resize.
+ *
+ * @return
+ * F_none on success.
+ *
+ * F_memory_not (with error bit) on out of memory.
+ * F_parameter (with error bit) if a parameter is invalid.
+ *
+ * Errors (with error bit) from: f_memory_adjust().
+ * Errors (with error bit) from: f_memory_destroy().
+ */
+#ifndef _di_f_type_uint16ss_adjust_
+ extern f_status_t f_type_uint16ss_adjust(const f_array_length_t length, f_uint16ss_t *uint16ss);
+#endif // _di_f_type_uint16ss_adjust_
+
+/**
+ * Append the source uint16ss onto the destination.
+ *
+ * @param source
+ * The source uint16ss to append.
+ * @param destination
+ * The destination ranges the source is appended onto.
+ *
+ * @return
+ * F_none on success.
+ *
+ * F_memory_not (with error bit) on out of memory.
+ * F_parameter (with error bit) if a parameter is invalid.
+ *
+ * Errors (with error bit) from: f_memory_resize().
+ */
+#ifndef _di_f_type_uint16ss_append_
+ extern f_status_t f_type_uint16ss_append(const f_uint16ss_t source, f_uint16ss_t *destination);
+#endif // _di_f_type_uint16ss_append_
+
+/**
+ * Resize the string uint16ss array.
+ *
+ * @param length
+ * The new size to use.
+ * @param uint16ss
+ * The string uint16ss array to resize.
+ *
+ * @return
+ * F_none on success.
+ *
+ * F_memory_not (with error bit) on out of memory.
+ * F_parameter (with error bit) if a parameter is invalid.
+ *
+ * Errors (with error bit) from: f_memory_adjust().
+ * Errors (with error bit) from: f_memory_destroy().
+ */
+#ifndef _di_f_type_uint16ss_adjust_
+ extern f_status_t f_type_uint16ss_adjust(const f_array_length_t length, f_uint16ss_t *uint16ss);
+#endif // _di_f_type_uint16ss_adjust_
+
+/**
+ * Resize the string uint16ss array to a smaller size.
+ *
+ * This will resize making the array smaller based on (size - given length).
+ * If the given length is too small, then the resize will fail.
+ * This will not shrink the size to less than 0.
+ *
+ * @param amount
+ * A positive number representing how much to decimate the size by.
+ * @param uint16ss
+ * The string uint16ss array to resize.
+ *
+ * @return
+ * F_none on success.
+ *
+ * F_memory_not (with error bit) on out of memory.
+ * F_parameter (with error bit) if a parameter is invalid.
+ *
+ * Errors (with error bit) from: f_memory_adjust().
+ * Errors (with error bit) from: f_memory_destroy().
+ */
+#ifndef _di_f_type_uint16ss_decimate_by_
+ extern f_status_t f_type_uint16ss_decimate_by(const f_array_length_t amount, f_uint16ss_t *uint16ss);
+#endif // _di_f_type_uint16ss_decimate_by_
+
+/**
+ * Resize the string uint16ss array to a smaller size.
+ *
+ * This will resize making the array smaller based on (size - given length).
+ * If the given length is too small, then the resize will fail.
+ * This will not shrink the size to less than 0.
+ *
+ * @param amount
+ * A positive number representing how much to decrease the size by.
+ * @param uint16ss
+ * The string uint16ss array to resize.
+ *
+ * @return
+ * F_none on success.
+ *
+ * F_memory_not (with error bit) on out of memory.
+ * F_parameter (with error bit) if a parameter is invalid.
+ *
+ * Errors (with error bit) from: f_memory_delete().
+ * Errors (with error bit) from: f_memory_resize().
+ */
+#ifndef _di_f_type_uint16ss_decrease_by_
+ extern f_status_t f_type_uint16ss_decrease_by(const f_array_length_t amount, f_uint16ss_t *uint16ss);
+#endif // _di_f_type_uint16ss_decrease_by_
+
+/**
+ * Increase the size of the string uint16ss array, but only if necessary.
+ *
+ * If the given length is too large for the buffer, then attempt to set max buffer size (f_array_length_t_size).
+ * If already set to the maximum buffer size, then the resize will fail.
+ *
+ * @param uint16ss
+ * The string uint16ss array to resize.
+ *
+ * @return
+ * F_none on success.
+ * F_data_not on success, but there is no reason to increase size (used + 1 <= size).
+ *
+ * F_array_too_large (with error bit) if the new array length is too large.
+ * F_memory_not (with error bit) on out of memory.
+ * F_parameter (with error bit) if a parameter is invalid.
+ *
+ * Errors (with error bit) from: f_memory_resize().
+ */
+#ifndef _di_f_type_uint16ss_increase_
+ extern f_status_t f_type_uint16ss_increase(f_uint16ss_t *uint16ss);
+#endif // _di_f_type_uint16ss_increase_
+
+/**
+ * Resize the string uint16ss array to a larger size.
+ *
+ * This will resize making the string larger based on the given length.
+ * If the given length is too large for the buffer, then attempt to set max buffer size (f_array_length_t_size).
+ * If already set to the maximum buffer size, then the resize will fail.
+ *
+ * @param amount
+ * A positive number representing how much to increase the size by.
+ * @param uint16ss
+ * The string uint16ss array to resize.
+ *
+ * @return
+ * F_none on success.
+ * F_data_not on success, but there is no reason to increase size (used + amount <= size).
+ *
+ * F_memory_not (with error bit) on out of memory.
+ * F_parameter (with error bit) if a parameter is invalid.
+ * F_array_too_large (with error bit) if the new array length is too large.
+ *
+ * Errors (with error bit) from: f_memory_resize().
+ */
+#ifndef _di_f_type_uint16ss_increase_by_
+ extern f_status_t f_type_uint16ss_increase_by(const f_array_length_t amount, f_uint16ss_t *uint16ss);
+#endif // _di_f_type_uint16ss_increase_by_
+
+/**
+ * Resize the string uint16ss array.
+ *
+ * @param length
+ * The new size to use.
+ * @param uint16ss
+ * The string uint16ss array to adjust.
+ *
+ * @return
+ * F_none on success.
+ *
+ * F_memory_not (with error bit) on out of memory.
+ * F_parameter (with error bit) if a parameter is invalid.
+ *
+ * Errors (with error bit) from: f_memory_delete().
+ * Errors (with error bit) from: f_memory_resize().
+ */
+#ifndef _di_f_type_uint16ss_resize_
+ extern f_status_t f_type_uint16ss_resize(const f_array_length_t length, f_uint16ss_t *uint16ss);
+#endif // _di_f_type_uint16ss_resize_
+
+/**
+ * Resize the string int32s array.
+ *
+ * @param length
+ * The new size to use.
+ * @param int32s
+ * The string int32s array to resize.
+ *
+ * @return
+ * F_none on success.
+ *
+ * F_parameter (with error bit) if a parameter is invalid.
+ *
+ * Errors (with error bit) from: f_memory_adjust().
+ */
+#ifndef _di_f_type_int32s_adjust_
+ extern f_status_t f_type_int32s_adjust(const f_array_length_t length, f_int32s_t *int32s);
+#endif // _di_f_type_int32s_adjust_
+
+/**
+ * Append the source int32s onto the destination.
+ *
+ * @param source
+ * The source int32s to append.
+ * @param destination
+ * The destination int32s the source is appended onto.
+ *
+ * @return
+ * F_none on success.
+ *
+ * F_parameter (with error bit) if a parameter is invalid.
+ *
+ * Errors (with error bit) from: f_memory_resize().
+ */
+#ifndef _di_f_type_int32s_append_
+ extern f_status_t f_type_int32s_append(const f_int32s_t source, f_int32s_t *destination);
+#endif // _di_f_type_int32s_append_
+
+/**
+ * Resize the string int32s array to a smaller size.
+ *
+ * This will resize making the array smaller based on (size - given length).
+ * If the given length is too small, then the resize will fail.
+ * This will not shrink the size to les than 0.
+ *
+ * @param amount
+ * A positive number representing how much to decimate the size by.
+ * @param int32s
+ * The string int32s array to resize.
+ *
+ * @return
+ * F_none on success.
+ *
+ * F_memory_not (with error bit) on out of memory.
+ * F_parameter (with error bit) if a parameter is invalid.
+ *
+ * Errors (with error bit) from: f_memory_adjust().
+ */
+#ifndef _di_f_type_int32s_decimate_by_
+ extern f_status_t f_type_int32s_decimate_by(const f_array_length_t amount, f_int32s_t *int32s);
+#endif // _di_f_type_int32s_decimate_by_
+
+/**
+ * Resize the string int32s array to a smaller size.
+ *
+ * This will resize making the array smaller based on (size - given length).
+ * If the given length is too small, then the resize will fail.
+ * This will not shrink the size to les than 0.
+ *
+ * @param amount
+ * A positive number representing how much to decrease the size by.
+ * @param int32s
+ * The string int32s array to resize.
+ *
+ * @return
+ * F_none on success.
+ *
+ * F_memory_not (with error bit) on out of memory.
+ * F_parameter (with error bit) if a parameter is invalid.
+ *
+ * Errors (with error bit) from: f_memory_resize().
+ */
+#ifndef _di_f_type_int32s_decrease_by_
+ extern f_status_t f_type_int32s_decrease_by(const f_array_length_t amount, f_int32s_t *int32s);
+#endif // _di_f_type_int32s_decrease_by_
+
+/**
+ * Increase the size of the string int32s array, but only if necesary.
+ *
+ * If the given length is too large for the buffer, then attempt to set max buffer size (f_array_length_t_size).
+ * If already set to the maximum buffer size, then the resize will fail.
+ *
+ * @param int32s
+ * The string int32s array to resize.
+ *
+ * @return
+ * F_none on success.
+ * F_data_not on success, but there is no reason to increase size (used + 1 <= size).
+ *
+ * F_array_too_large (with error bit) if the new array length is too large.
+ * F_memory_not (with error bit) on out of memory.
+ * F_parameter (with error bit) if a parameter is invalid.
+ *
+ * Errors (with error bit) from: f_memory_resize().
+ */
+#ifndef _di_f_type_int32s_increase_
+ extern f_status_t f_type_int32s_increase(f_int32s_t *int32s);
+#endif // _di_f_type_int32s_increase_
+
+/**
+ * Resize the string int32s array to a larger size.
+ *
+ * This will resize making the string larger based on the given length.
+ * If the given length is too large for the buffer, then attempt to set max buffer size (f_array_length_t_size).
+ * If already set to the maximum buffer size, then the resize will fail.
+ *
+ * @param amount
+ * A positive number representing how much to increase the size by.
+ * @param int32s
+ * The string int32s array to resize.
+ *
+ * @return
+ * F_none on success.
+ * F_data_not on success, but there is no reason to increase size (used + amount <= size).
+ *
+ * F_memory_not (with error bit) on out of memory.
+ * F_parameter (with error bit) if a parameter is invalid.
+ * F_array_too_large (with error bit) if the new array length is too large.
+ *
+ * Errors (with error bit) from: f_memory_resize().
+ */
+#ifndef _di_f_type_int32s_increase_by_
+ extern f_status_t f_type_int32s_increase_by(const f_array_length_t amount, f_int32s_t *int32s);
+#endif // _di_f_type_int32s_increase_by_
+
+/**
+ * Resize the string int32s array.
+ *
+ * @param length
+ * The new size to use.
+ * @param int32s
+ * The string int32s array to adjust.
+ *
+ * @return
+ * F_none on success.
+ *
+ * F_memory_not (with error bit) on out of memory.
+ * F_parameter (with error bit) if a parameter is invalid.
+ *
+ * Errors (with error bit) from: f_memory_resize().
+ */
+#ifndef _di_f_type_int32s_resize_
+ extern f_status_t f_type_int32s_resize(const f_array_length_t length, f_int32s_t *int32s);
+#endif // _di_f_type_int32s_resize_
+
+/**
+ * Resize the string int32ss array.
+ *
+ * @param length
+ * The new size to use.
+ * @param int32ss
+ * The string int32ss array to resize.
+ *
+ * @return
+ * F_none on success.
+ *
+ * F_memory_not (with error bit) on out of memory.
+ * F_parameter (with error bit) if a parameter is invalid.
+ *
+ * Errors (with error bit) from: f_memory_adjust().
+ * Errors (with error bit) from: f_memory_destroy().
+ */
+#ifndef _di_f_type_int32ss_adjust_
+ extern f_status_t f_type_int32ss_adjust(const f_array_length_t length, f_int32ss_t *int32ss);
+#endif // _di_f_type_int32ss_adjust_
+
+/**
+ * Append the source int32ss onto the destination.
+ *
+ * @param source
+ * The source int32ss to append.
+ * @param destination
+ * The destination ranges the source is appended onto.
+ *
+ * @return
+ * F_none on success.
+ *
+ * F_memory_not (with error bit) on out of memory.
+ * F_parameter (with error bit) if a parameter is invalid.
+ *
+ * Errors (with error bit) from: f_memory_resize().
+ */
+#ifndef _di_f_type_int32ss_append_
+ extern f_status_t f_type_int32ss_append(const f_int32ss_t source, f_int32ss_t *destination);
+#endif // _di_f_type_int32ss_append_
+
+/**
+ * Resize the string int32ss array.
+ *
+ * @param length
+ * The new size to use.
+ * @param int32ss
+ * The string int32ss array to resize.
+ *
+ * @return
+ * F_none on success.
+ *
+ * F_memory_not (with error bit) on out of memory.
+ * F_parameter (with error bit) if a parameter is invalid.
+ *
+ * Errors (with error bit) from: f_memory_adjust().
+ * Errors (with error bit) from: f_memory_destroy().
+ */
+#ifndef _di_f_type_int32ss_adjust_
+ extern f_status_t f_type_int32ss_adjust(const f_array_length_t length, f_int32ss_t *int32ss);
+#endif // _di_f_type_int32ss_adjust_
+
+/**
+ * Resize the string int32ss array to a smaller size.
+ *
+ * This will resize making the array smaller based on (size - given length).
+ * If the given length is too small, then the resize will fail.
+ * This will not shrink the size to less than 0.
+ *
+ * @param amount
+ * A positive number representing how much to decimate the size by.
+ * @param int32ss
+ * The string int32ss array to resize.
+ *
+ * @return
+ * F_none on success.
+ *
+ * F_memory_not (with error bit) on out of memory.
+ * F_parameter (with error bit) if a parameter is invalid.
+ *
+ * Errors (with error bit) from: f_memory_adjust().
+ * Errors (with error bit) from: f_memory_destroy().
+ */
+#ifndef _di_f_type_int32ss_decimate_by_
+ extern f_status_t f_type_int32ss_decimate_by(const f_array_length_t amount, f_int32ss_t *int32ss);
+#endif // _di_f_type_int32ss_decimate_by_
+
+/**
+ * Resize the string int32ss array to a smaller size.
+ *
+ * This will resize making the array smaller based on (size - given length).
+ * If the given length is too small, then the resize will fail.
+ * This will not shrink the size to less than 0.
+ *
+ * @param amount
+ * A positive number representing how much to decrease the size by.
+ * @param int32ss
+ * The string int32ss array to resize.
+ *
+ * @return
+ * F_none on success.
+ *
+ * F_memory_not (with error bit) on out of memory.
+ * F_parameter (with error bit) if a parameter is invalid.
+ *
+ * Errors (with error bit) from: f_memory_delete().
+ * Errors (with error bit) from: f_memory_resize().
+ */
+#ifndef _di_f_type_int32ss_decrease_by_
+ extern f_status_t f_type_int32ss_decrease_by(const f_array_length_t amount, f_int32ss_t *int32ss);
+#endif // _di_f_type_int32ss_decrease_by_
+
+/**
+ * Increase the size of the string int32ss array, but only if necessary.
+ *
+ * If the given length is too large for the buffer, then attempt to set max buffer size (f_array_length_t_size).
+ * If already set to the maximum buffer size, then the resize will fail.
+ *
+ * @param int32ss
+ * The string int32ss array to resize.
+ *
+ * @return
+ * F_none on success.
+ * F_data_not on success, but there is no reason to increase size (used + 1 <= size).
+ *
+ * F_array_too_large (with error bit) if the new array length is too large.
+ * F_memory_not (with error bit) on out of memory.
+ * F_parameter (with error bit) if a parameter is invalid.
+ *
+ * Errors (with error bit) from: f_memory_resize().
+ */
+#ifndef _di_f_type_int32ss_increase_
+ extern f_status_t f_type_int32ss_increase(f_int32ss_t *int32ss);
+#endif // _di_f_type_int32ss_increase_
+
+/**
+ * Resize the string int32ss array to a larger size.
+ *
+ * This will resize making the string larger based on the given length.
+ * If the given length is too large for the buffer, then attempt to set max buffer size (f_array_length_t_size).
+ * If already set to the maximum buffer size, then the resize will fail.
+ *
+ * @param amount
+ * A positive number representing how much to increase the size by.
+ * @param int32ss
+ * The string int32ss array to resize.
+ *
+ * @return
+ * F_none on success.
+ * F_data_not on success, but there is no reason to increase size (used + amount <= size).
+ *
+ * F_memory_not (with error bit) on out of memory.
+ * F_parameter (with error bit) if a parameter is invalid.
+ * F_array_too_large (with error bit) if the new array length is too large.
+ *
+ * Errors (with error bit) from: f_memory_resize().
+ */
+#ifndef _di_f_type_int32ss_increase_by_
+ extern f_status_t f_type_int32ss_increase_by(const f_array_length_t amount, f_int32ss_t *int32ss);
+#endif // _di_f_type_int32ss_increase_by_
+
+/**
+ * Resize the string int32ss array.
+ *
+ * @param length
+ * The new size to use.
+ * @param int32ss
+ * The string int32ss array to adjust.
+ *
+ * @return
+ * F_none on success.
+ *
+ * F_memory_not (with error bit) on out of memory.
+ * F_parameter (with error bit) if a parameter is invalid.
+ *
+ * Errors (with error bit) from: f_memory_delete().
+ * Errors (with error bit) from: f_memory_resize().
+ */
+#ifndef _di_f_type_int32ss_resize_
+ extern f_status_t f_type_int32ss_resize(const f_array_length_t length, f_int32ss_t *int32ss);
+#endif // _di_f_type_int32ss_resize_
+
+/**
+ * Resize the string uint32s array.
+ *
+ * @param length
+ * The new size to use.
+ * @param uint32s
+ * The string uint32s array to resize.
+ *
+ * @return
+ * F_none on success.
+ *
+ * F_parameter (with error bit) if a parameter is invalid.
+ *
+ * Errors (with error bit) from: f_memory_adjust().
+ */
+#ifndef _di_f_type_uint32s_adjust_
+ extern f_status_t f_type_uint32s_adjust(const f_array_length_t length, f_uint32s_t *uint32s);
+#endif // _di_f_type_uint32s_adjust_
+
+/**
+ * Append the source uint32s onto the destination.
+ *
+ * @param source
+ * The source uint32s to append.
+ * @param destination
+ * The destination uint32s the source is appended onto.
+ *
+ * @return
+ * F_none on success.
+ *
+ * F_parameter (with error bit) if a parameter is invalid.
+ *
+ * Errors (with error bit) from: f_memory_resize().
+ */
+#ifndef _di_f_type_uint32s_append_
+ extern f_status_t f_type_uint32s_append(const f_uint32s_t source, f_uint32s_t *destination);
+#endif // _di_f_type_uint32s_append_
+
+/**
+ * Resize the string uint32s array to a smaller size.
+ *
+ * This will resize making the array smaller based on (size - given length).
+ * If the given length is too small, then the resize will fail.
+ * This will not shrink the size to les than 0.
+ *
+ * @param amount
+ * A positive number representing how much to decimate the size by.
+ * @param uint32s
+ * The string uint32s array to resize.
+ *
+ * @return
+ * F_none on success.
+ *
+ * F_memory_not (with error bit) on out of memory.
+ * F_parameter (with error bit) if a parameter is invalid.
+ *
+ * Errors (with error bit) from: f_memory_adjust().
+ */
+#ifndef _di_f_type_uint32s_decimate_by_
+ extern f_status_t f_type_uint32s_decimate_by(const f_array_length_t amount, f_uint32s_t *uint32s);
+#endif // _di_f_type_uint32s_decimate_by_
+
+/**
+ * Resize the string uint32s array to a smaller size.
+ *
+ * This will resize making the array smaller based on (size - given length).
+ * If the given length is too small, then the resize will fail.
+ * This will not shrink the size to les than 0.
+ *
+ * @param amount
+ * A positive number representing how much to decrease the size by.
+ * @param uint32s
+ * The string uint32s array to resize.
+ *
+ * @return
+ * F_none on success.
+ *
+ * F_memory_not (with error bit) on out of memory.
+ * F_parameter (with error bit) if a parameter is invalid.
+ *
+ * Errors (with error bit) from: f_memory_resize().
+ */
+#ifndef _di_f_type_uint32s_decrease_by_
+ extern f_status_t f_type_uint32s_decrease_by(const f_array_length_t amount, f_uint32s_t *uint32s);
+#endif // _di_f_type_uint32s_decrease_by_
+
+/**
+ * Increase the size of the string uint32s array, but only if necesary.
+ *
+ * If the given length is too large for the buffer, then attempt to set max buffer size (f_array_length_t_size).
+ * If already set to the maximum buffer size, then the resize will fail.
+ *
+ * @param uint32s
+ * The string uint32s array to resize.
+ *
+ * @return
+ * F_none on success.
+ * F_data_not on success, but there is no reason to increase size (used + 1 <= size).
+ *
+ * F_array_too_large (with error bit) if the new array length is too large.
+ * F_memory_not (with error bit) on out of memory.
+ * F_parameter (with error bit) if a parameter is invalid.
+ *
+ * Errors (with error bit) from: f_memory_resize().
+ */
+#ifndef _di_f_type_uint32s_increase_
+ extern f_status_t f_type_uint32s_increase(f_uint32s_t *uint32s);
+#endif // _di_f_type_uint32s_increase_
+
+/**
+ * Resize the string uint32s array to a larger size.
+ *
+ * This will resize making the string larger based on the given length.
+ * If the given length is too large for the buffer, then attempt to set max buffer size (f_array_length_t_size).
+ * If already set to the maximum buffer size, then the resize will fail.
+ *
+ * @param amount
+ * A positive number representing how much to increase the size by.
+ * @param uint32s
+ * The string uint32s array to resize.
+ *
+ * @return
+ * F_none on success.
+ * F_data_not on success, but there is no reason to increase size (used + amount <= size).
+ *
+ * F_memory_not (with error bit) on out of memory.
+ * F_parameter (with error bit) if a parameter is invalid.
+ * F_array_too_large (with error bit) if the new array length is too large.
+ *
+ * Errors (with error bit) from: f_memory_resize().
+ */
+#ifndef _di_f_type_uint32s_increase_by_
+ extern f_status_t f_type_uint32s_increase_by(const f_array_length_t amount, f_uint32s_t *uint32s);
+#endif // _di_f_type_uint32s_increase_by_
+
+/**
+ * Resize the string uint32s array.
+ *
+ * @param length
+ * The new size to use.
+ * @param uint32s
+ * The string uint32s array to adjust.
+ *
+ * @return
+ * F_none on success.
+ *
+ * F_memory_not (with error bit) on out of memory.
+ * F_parameter (with error bit) if a parameter is invalid.
+ *
+ * Errors (with error bit) from: f_memory_resize().
+ */
+#ifndef _di_f_type_uint32s_resize_
+ extern f_status_t f_type_uint32s_resize(const f_array_length_t length, f_uint32s_t *uint32s);
+#endif // _di_f_type_uint32s_resize_
+
+/**
+ * Resize the string uint32ss array.
+ *
+ * @param length
+ * The new size to use.
+ * @param uint32ss
+ * The string uint32ss array to resize.
+ *
+ * @return
+ * F_none on success.
+ *
+ * F_memory_not (with error bit) on out of memory.
+ * F_parameter (with error bit) if a parameter is invalid.
+ *
+ * Errors (with error bit) from: f_memory_adjust().
+ * Errors (with error bit) from: f_memory_destroy().
+ */
+#ifndef _di_f_type_uint32ss_adjust_
+ extern f_status_t f_type_uint32ss_adjust(const f_array_length_t length, f_uint32ss_t *uint32ss);
+#endif // _di_f_type_uint32ss_adjust_
+
+/**
+ * Append the source uint32ss onto the destination.
+ *
+ * @param source
+ * The source uint32ss to append.
+ * @param destination
+ * The destination ranges the source is appended onto.
+ *
+ * @return
+ * F_none on success.
+ *
+ * F_memory_not (with error bit) on out of memory.
+ * F_parameter (with error bit) if a parameter is invalid.
+ *
+ * Errors (with error bit) from: f_memory_resize().
+ */
+#ifndef _di_f_type_uint32ss_append_
+ extern f_status_t f_type_uint32ss_append(const f_uint32ss_t source, f_uint32ss_t *destination);
+#endif // _di_f_type_uint32ss_append_
+
+/**
+ * Resize the string uint32ss array.
+ *
+ * @param length
+ * The new size to use.
+ * @param uint32ss
+ * The string uint32ss array to resize.
+ *
+ * @return
+ * F_none on success.
+ *
+ * F_memory_not (with error bit) on out of memory.
+ * F_parameter (with error bit) if a parameter is invalid.
+ *
+ * Errors (with error bit) from: f_memory_adjust().
+ * Errors (with error bit) from: f_memory_destroy().
+ */
+#ifndef _di_f_type_uint32ss_adjust_
+ extern f_status_t f_type_uint32ss_adjust(const f_array_length_t length, f_uint32ss_t *uint32ss);
+#endif // _di_f_type_uint32ss_adjust_
+
+/**
+ * Resize the string uint32ss array to a smaller size.
+ *
+ * This will resize making the array smaller based on (size - given length).
+ * If the given length is too small, then the resize will fail.
+ * This will not shrink the size to less than 0.
+ *
+ * @param amount
+ * A positive number representing how much to decimate the size by.
+ * @param uint32ss
+ * The string uint32ss array to resize.
+ *
+ * @return
+ * F_none on success.
+ *
+ * F_memory_not (with error bit) on out of memory.
+ * F_parameter (with error bit) if a parameter is invalid.
+ *
+ * Errors (with error bit) from: f_memory_adjust().
+ * Errors (with error bit) from: f_memory_destroy().
+ */
+#ifndef _di_f_type_uint32ss_decimate_by_
+ extern f_status_t f_type_uint32ss_decimate_by(const f_array_length_t amount, f_uint32ss_t *uint32ss);
+#endif // _di_f_type_uint32ss_decimate_by_
+
+/**
+ * Resize the string uint32ss array to a smaller size.
+ *
+ * This will resize making the array smaller based on (size - given length).
+ * If the given length is too small, then the resize will fail.
+ * This will not shrink the size to less than 0.
+ *
+ * @param amount
+ * A positive number representing how much to decrease the size by.
+ * @param uint32ss
+ * The string uint32ss array to resize.
+ *
+ * @return
+ * F_none on success.
+ *
+ * F_memory_not (with error bit) on out of memory.
+ * F_parameter (with error bit) if a parameter is invalid.
+ *
+ * Errors (with error bit) from: f_memory_delete().
+ * Errors (with error bit) from: f_memory_resize().
+ */
+#ifndef _di_f_type_uint32ss_decrease_by_
+ extern f_status_t f_type_uint32ss_decrease_by(const f_array_length_t amount, f_uint32ss_t *uint32ss);
+#endif // _di_f_type_uint32ss_decrease_by_
+
+/**
+ * Increase the size of the string uint32ss array, but only if necessary.
+ *
+ * If the given length is too large for the buffer, then attempt to set max buffer size (f_array_length_t_size).
+ * If already set to the maximum buffer size, then the resize will fail.
+ *
+ * @param uint32ss
+ * The string uint32ss array to resize.
+ *
+ * @return
+ * F_none on success.
+ * F_data_not on success, but there is no reason to increase size (used + 1 <= size).
+ *
+ * F_array_too_large (with error bit) if the new array length is too large.
+ * F_memory_not (with error bit) on out of memory.
+ * F_parameter (with error bit) if a parameter is invalid.
+ *
+ * Errors (with error bit) from: f_memory_resize().
+ */
+#ifndef _di_f_type_uint32ss_increase_
+ extern f_status_t f_type_uint32ss_increase(f_uint32ss_t *uint32ss);
+#endif // _di_f_type_uint32ss_increase_
+
+/**
+ * Resize the string uint32ss array to a larger size.
+ *
+ * This will resize making the string larger based on the given length.
+ * If the given length is too large for the buffer, then attempt to set max buffer size (f_array_length_t_size).
+ * If already set to the maximum buffer size, then the resize will fail.
+ *
+ * @param amount
+ * A positive number representing how much to increase the size by.
+ * @param uint32ss
+ * The string uint32ss array to resize.
+ *
+ * @return
+ * F_none on success.
+ * F_data_not on success, but there is no reason to increase size (used + amount <= size).
+ *
+ * F_memory_not (with error bit) on out of memory.
+ * F_parameter (with error bit) if a parameter is invalid.
+ * F_array_too_large (with error bit) if the new array length is too large.
+ *
+ * Errors (with error bit) from: f_memory_resize().
+ */
+#ifndef _di_f_type_uint32ss_increase_by_
+ extern f_status_t f_type_uint32ss_increase_by(const f_array_length_t amount, f_uint32ss_t *uint32ss);
+#endif // _di_f_type_uint32ss_increase_by_
+
+/**
+ * Resize the string uint32ss array.
+ *
+ * @param length
+ * The new size to use.
+ * @param uint32ss
+ * The string uint32ss array to adjust.
+ *
+ * @return
+ * F_none on success.
+ *
+ * F_memory_not (with error bit) on out of memory.
+ * F_parameter (with error bit) if a parameter is invalid.
+ *
+ * Errors (with error bit) from: f_memory_delete().
+ * Errors (with error bit) from: f_memory_resize().
+ */
+#ifndef _di_f_type_uint32ss_resize_
+ extern f_status_t f_type_uint32ss_resize(const f_array_length_t length, f_uint32ss_t *uint32ss);
+#endif // _di_f_type_uint32ss_resize_
+
+/**
+ * Resize the string int64s array.
+ *
+ * @param length
+ * The new size to use.
+ * @param int64s
+ * The string int64s array to resize.
+ *
+ * @return
+ * F_none on success.
+ *
+ * F_parameter (with error bit) if a parameter is invalid.
+ *
+ * Errors (with error bit) from: f_memory_adjust().
+ */
+#ifndef _di_f_type_int64s_adjust_
+ extern f_status_t f_type_int64s_adjust(const f_array_length_t length, f_int64s_t *int64s);
+#endif // _di_f_type_int64s_adjust_
+
+/**
+ * Append the source int64s onto the destination.
+ *
+ * @param source
+ * The source int64s to append.
+ * @param destination
+ * The destination int64s the source is appended onto.
+ *
+ * @return
+ * F_none on success.
+ *
+ * F_parameter (with error bit) if a parameter is invalid.
+ *
+ * Errors (with error bit) from: f_memory_resize().
+ */
+#ifndef _di_f_type_int64s_append_
+ extern f_status_t f_type_int64s_append(const f_int64s_t source, f_int64s_t *destination);
+#endif // _di_f_type_int64s_append_
+
+/**
+ * Resize the string int64s array to a smaller size.
+ *
+ * This will resize making the array smaller based on (size - given length).
+ * If the given length is too small, then the resize will fail.
+ * This will not shrink the size to les than 0.
+ *
+ * @param amount
+ * A positive number representing how much to decimate the size by.
+ * @param int64s
+ * The string int64s array to resize.
+ *
+ * @return
+ * F_none on success.
+ *
+ * F_memory_not (with error bit) on out of memory.
+ * F_parameter (with error bit) if a parameter is invalid.
+ *
+ * Errors (with error bit) from: f_memory_adjust().
+ */
+#ifndef _di_f_type_int64s_decimate_by_
+ extern f_status_t f_type_int64s_decimate_by(const f_array_length_t amount, f_int64s_t *int64s);
+#endif // _di_f_type_int64s_decimate_by_
+
+/**
+ * Resize the string int64s array to a smaller size.
+ *
+ * This will resize making the array smaller based on (size - given length).
+ * If the given length is too small, then the resize will fail.
+ * This will not shrink the size to les than 0.
+ *
+ * @param amount
+ * A positive number representing how much to decrease the size by.
+ * @param int64s
+ * The string int64s array to resize.
+ *
+ * @return
+ * F_none on success.
+ *
+ * F_memory_not (with error bit) on out of memory.
+ * F_parameter (with error bit) if a parameter is invalid.
+ *
+ * Errors (with error bit) from: f_memory_resize().
+ */
+#ifndef _di_f_type_int64s_decrease_by_
+ extern f_status_t f_type_int64s_decrease_by(const f_array_length_t amount, f_int64s_t *int64s);
+#endif // _di_f_type_int64s_decrease_by_
+
+/**
+ * Increase the size of the string int64s array, but only if necesary.
+ *
+ * If the given length is too large for the buffer, then attempt to set max buffer size (f_array_length_t_size).
+ * If already set to the maximum buffer size, then the resize will fail.
+ *
+ * @param int64s
+ * The string int64s array to resize.
+ *
+ * @return
+ * F_none on success.
+ * F_data_not on success, but there is no reason to increase size (used + 1 <= size).
+ *
+ * F_array_too_large (with error bit) if the new array length is too large.
+ * F_memory_not (with error bit) on out of memory.
+ * F_parameter (with error bit) if a parameter is invalid.
+ *
+ * Errors (with error bit) from: f_memory_resize().
+ */
+#ifndef _di_f_type_int64s_increase_
+ extern f_status_t f_type_int64s_increase(f_int64s_t *int64s);
+#endif // _di_f_type_int64s_increase_
+
+/**
+ * Resize the string int64s array to a larger size.
+ *
+ * This will resize making the string larger based on the given length.
+ * If the given length is too large for the buffer, then attempt to set max buffer size (f_array_length_t_size).
+ * If already set to the maximum buffer size, then the resize will fail.
+ *
+ * @param amount
+ * A positive number representing how much to increase the size by.
+ * @param int64s
+ * The string int64s array to resize.
+ *
+ * @return
+ * F_none on success.
+ * F_data_not on success, but there is no reason to increase size (used + amount <= size).
+ *
+ * F_memory_not (with error bit) on out of memory.
+ * F_parameter (with error bit) if a parameter is invalid.
+ * F_array_too_large (with error bit) if the new array length is too large.
+ *
+ * Errors (with error bit) from: f_memory_resize().
+ */
+#ifndef _di_f_type_int64s_increase_by_
+ extern f_status_t f_type_int64s_increase_by(const f_array_length_t amount, f_int64s_t *int64s);
+#endif // _di_f_type_int64s_increase_by_
+
+/**
+ * Resize the string int64s array.
+ *
+ * @param length
+ * The new size to use.
+ * @param int64s
+ * The string int64s array to adjust.
+ *
+ * @return
+ * F_none on success.
+ *
+ * F_memory_not (with error bit) on out of memory.
+ * F_parameter (with error bit) if a parameter is invalid.
+ *
+ * Errors (with error bit) from: f_memory_resize().
+ */
+#ifndef _di_f_type_int64s_resize_
+ extern f_status_t f_type_int64s_resize(const f_array_length_t length, f_int64s_t *int64s);
+#endif // _di_f_type_int64s_resize_
+
+/**
+ * Resize the string int64ss array.
+ *
+ * @param length
+ * The new size to use.
+ * @param int64ss
+ * The string int64ss array to resize.
+ *
+ * @return
+ * F_none on success.
+ *
+ * F_memory_not (with error bit) on out of memory.
+ * F_parameter (with error bit) if a parameter is invalid.
+ *
+ * Errors (with error bit) from: f_memory_adjust().
+ * Errors (with error bit) from: f_memory_destroy().
+ */
+#ifndef _di_f_type_int64ss_adjust_
+ extern f_status_t f_type_int64ss_adjust(const f_array_length_t length, f_int64ss_t *int64ss);
+#endif // _di_f_type_int64ss_adjust_
+
+/**
+ * Append the source int64ss onto the destination.
+ *
+ * @param source
+ * The source int64ss to append.
+ * @param destination
+ * The destination ranges the source is appended onto.
+ *
+ * @return
+ * F_none on success.
+ *
+ * F_memory_not (with error bit) on out of memory.
+ * F_parameter (with error bit) if a parameter is invalid.
+ *
+ * Errors (with error bit) from: f_memory_resize().
+ */
+#ifndef _di_f_type_int64ss_append_
+ extern f_status_t f_type_int64ss_append(const f_int64ss_t source, f_int64ss_t *destination);
+#endif // _di_f_type_int64ss_append_
+
+/**
+ * Resize the string int64ss array.
+ *
+ * @param length
+ * The new size to use.
+ * @param int64ss
+ * The string int64ss array to resize.
+ *
+ * @return
+ * F_none on success.
+ *
+ * F_memory_not (with error bit) on out of memory.
+ * F_parameter (with error bit) if a parameter is invalid.
+ *
+ * Errors (with error bit) from: f_memory_adjust().
+ * Errors (with error bit) from: f_memory_destroy().
+ */
+#ifndef _di_f_type_int64ss_adjust_
+ extern f_status_t f_type_int64ss_adjust(const f_array_length_t length, f_int64ss_t *int64ss);
+#endif // _di_f_type_int64ss_adjust_
+
+/**
+ * Resize the string int64ss array to a smaller size.
+ *
+ * This will resize making the array smaller based on (size - given length).
+ * If the given length is too small, then the resize will fail.
+ * This will not shrink the size to less than 0.
+ *
+ * @param amount
+ * A positive number representing how much to decimate the size by.
+ * @param int64ss
+ * The string int64ss array to resize.
+ *
+ * @return
+ * F_none on success.
+ *
+ * F_memory_not (with error bit) on out of memory.
+ * F_parameter (with error bit) if a parameter is invalid.
+ *
+ * Errors (with error bit) from: f_memory_adjust().
+ * Errors (with error bit) from: f_memory_destroy().
+ */
+#ifndef _di_f_type_int64ss_decimate_by_
+ extern f_status_t f_type_int64ss_decimate_by(const f_array_length_t amount, f_int64ss_t *int64ss);
+#endif // _di_f_type_int64ss_decimate_by_
+
+/**
+ * Resize the string int64ss array to a smaller size.
+ *
+ * This will resize making the array smaller based on (size - given length).
+ * If the given length is too small, then the resize will fail.
+ * This will not shrink the size to less than 0.
+ *
+ * @param amount
+ * A positive number representing how much to decrease the size by.
+ * @param int64ss
+ * The string int64ss array to resize.
+ *
+ * @return
+ * F_none on success.
+ *
+ * F_memory_not (with error bit) on out of memory.
+ * F_parameter (with error bit) if a parameter is invalid.
+ *
+ * Errors (with error bit) from: f_memory_delete().
+ * Errors (with error bit) from: f_memory_resize().
+ */
+#ifndef _di_f_type_int64ss_decrease_by_
+ extern f_status_t f_type_int64ss_decrease_by(const f_array_length_t amount, f_int64ss_t *int64ss);
+#endif // _di_f_type_int64ss_decrease_by_
+
+/**
+ * Increase the size of the string int64ss array, but only if necessary.
+ *
+ * If the given length is too large for the buffer, then attempt to set max buffer size (f_array_length_t_size).
+ * If already set to the maximum buffer size, then the resize will fail.
+ *
+ * @param int64ss
+ * The string int64ss array to resize.
+ *
+ * @return
+ * F_none on success.
+ * F_data_not on success, but there is no reason to increase size (used + 1 <= size).
+ *
+ * F_array_too_large (with error bit) if the new array length is too large.
+ * F_memory_not (with error bit) on out of memory.
+ * F_parameter (with error bit) if a parameter is invalid.
+ *
+ * Errors (with error bit) from: f_memory_resize().
+ */
+#ifndef _di_f_type_int64ss_increase_
+ extern f_status_t f_type_int64ss_increase(f_int64ss_t *int64ss);
+#endif // _di_f_type_int64ss_increase_
+
+/**
+ * Resize the string int64ss array to a larger size.
+ *
+ * This will resize making the string larger based on the given length.
+ * If the given length is too large for the buffer, then attempt to set max buffer size (f_array_length_t_size).
+ * If already set to the maximum buffer size, then the resize will fail.
+ *
+ * @param amount
+ * A positive number representing how much to increase the size by.
+ * @param int64ss
+ * The string int64ss array to resize.
+ *
+ * @return
+ * F_none on success.
+ * F_data_not on success, but there is no reason to increase size (used + amount <= size).
+ *
+ * F_memory_not (with error bit) on out of memory.
+ * F_parameter (with error bit) if a parameter is invalid.
+ * F_array_too_large (with error bit) if the new array length is too large.
+ *
+ * Errors (with error bit) from: f_memory_resize().
*/
-#ifndef _di_f_type_uint32ss_decimate_by_
- extern f_status_t f_type_uint32ss_decimate_by(const f_array_length_t amount, f_uint32ss_t *uint32ss);
-#endif // _di_f_type_uint32ss_decimate_by_
+#ifndef _di_f_type_int64ss_increase_by_
+ extern f_status_t f_type_int64ss_increase_by(const f_array_length_t amount, f_int64ss_t *int64ss);
+#endif // _di_f_type_int64ss_increase_by_
/**
- * Resize the string uint32ss array to a smaller size.
+ * Resize the string int64ss array.
+ *
+ * @param length
+ * The new size to use.
+ * @param int64ss
+ * The string int64ss array to adjust.
+ *
+ * @return
+ * F_none on success.
+ *
+ * F_memory_not (with error bit) on out of memory.
+ * F_parameter (with error bit) if a parameter is invalid.
+ *
+ * Errors (with error bit) from: f_memory_delete().
+ * Errors (with error bit) from: f_memory_resize().
+ */
+#ifndef _di_f_type_int64ss_resize_
+ extern f_status_t f_type_int64ss_resize(const f_array_length_t length, f_int64ss_t *int64ss);
+#endif // _di_f_type_int64ss_resize_
+
+/**
+ * Resize the string uint64s array.
+ *
+ * @param length
+ * The new size to use.
+ * @param uint64s
+ * The string uint64s array to resize.
+ *
+ * @return
+ * F_none on success.
+ *
+ * F_parameter (with error bit) if a parameter is invalid.
+ *
+ * Errors (with error bit) from: f_memory_adjust().
+ */
+#ifndef _di_f_type_uint64s_adjust_
+ extern f_status_t f_type_uint64s_adjust(const f_array_length_t length, f_uint64s_t *uint64s);
+#endif // _di_f_type_uint64s_adjust_
+
+/**
+ * Append the source uint64s onto the destination.
+ *
+ * @param source
+ * The source uint64s to append.
+ * @param destination
+ * The destination uint64s the source is appended onto.
+ *
+ * @return
+ * F_none on success.
+ *
+ * F_parameter (with error bit) if a parameter is invalid.
+ *
+ * Errors (with error bit) from: f_memory_resize().
+ */
+#ifndef _di_f_type_uint64s_append_
+ extern f_status_t f_type_uint64s_append(const f_uint64s_t source, f_uint64s_t *destination);
+#endif // _di_f_type_uint64s_append_
+
+/**
+ * Resize the string uint64s array to a smaller size.
+ *
+ * This will resize making the array smaller based on (size - given length).
+ * If the given length is too small, then the resize will fail.
+ * This will not shrink the size to les than 0.
+ *
+ * @param amount
+ * A positive number representing how much to decimate the size by.
+ * @param uint64s
+ * The string uint64s array to resize.
+ *
+ * @return
+ * F_none on success.
+ *
+ * F_memory_not (with error bit) on out of memory.
+ * F_parameter (with error bit) if a parameter is invalid.
+ *
+ * Errors (with error bit) from: f_memory_adjust().
+ */
+#ifndef _di_f_type_uint64s_decimate_by_
+ extern f_status_t f_type_uint64s_decimate_by(const f_array_length_t amount, f_uint64s_t *uint64s);
+#endif // _di_f_type_uint64s_decimate_by_
+
+/**
+ * Resize the string uint64s array to a smaller size.
+ *
+ * This will resize making the array smaller based on (size - given length).
+ * If the given length is too small, then the resize will fail.
+ * This will not shrink the size to les than 0.
+ *
+ * @param amount
+ * A positive number representing how much to decrease the size by.
+ * @param uint64s
+ * The string uint64s array to resize.
+ *
+ * @return
+ * F_none on success.
+ *
+ * F_memory_not (with error bit) on out of memory.
+ * F_parameter (with error bit) if a parameter is invalid.
+ *
+ * Errors (with error bit) from: f_memory_resize().
+ */
+#ifndef _di_f_type_uint64s_decrease_by_
+ extern f_status_t f_type_uint64s_decrease_by(const f_array_length_t amount, f_uint64s_t *uint64s);
+#endif // _di_f_type_uint64s_decrease_by_
+
+/**
+ * Increase the size of the string uint64s array, but only if necesary.
+ *
+ * If the given length is too large for the buffer, then attempt to set max buffer size (f_array_length_t_size).
+ * If already set to the maximum buffer size, then the resize will fail.
+ *
+ * @param uint64s
+ * The string uint64s array to resize.
+ *
+ * @return
+ * F_none on success.
+ * F_data_not on success, but there is no reason to increase size (used + 1 <= size).
+ *
+ * F_array_too_large (with error bit) if the new array length is too large.
+ * F_memory_not (with error bit) on out of memory.
+ * F_parameter (with error bit) if a parameter is invalid.
+ *
+ * Errors (with error bit) from: f_memory_resize().
+ */
+#ifndef _di_f_type_uint64s_increase_
+ extern f_status_t f_type_uint64s_increase(f_uint64s_t *uint64s);
+#endif // _di_f_type_uint64s_increase_
+
+/**
+ * Resize the string uint64s array to a larger size.
+ *
+ * This will resize making the string larger based on the given length.
+ * If the given length is too large for the buffer, then attempt to set max buffer size (f_array_length_t_size).
+ * If already set to the maximum buffer size, then the resize will fail.
+ *
+ * @param amount
+ * A positive number representing how much to increase the size by.
+ * @param uint64s
+ * The string uint64s array to resize.
+ *
+ * @return
+ * F_none on success.
+ * F_data_not on success, but there is no reason to increase size (used + amount <= size).
+ *
+ * F_memory_not (with error bit) on out of memory.
+ * F_parameter (with error bit) if a parameter is invalid.
+ * F_array_too_large (with error bit) if the new array length is too large.
+ *
+ * Errors (with error bit) from: f_memory_resize().
+ */
+#ifndef _di_f_type_uint64s_increase_by_
+ extern f_status_t f_type_uint64s_increase_by(const f_array_length_t amount, f_uint64s_t *uint64s);
+#endif // _di_f_type_uint64s_increase_by_
+
+/**
+ * Resize the string uint64s array.
+ *
+ * @param length
+ * The new size to use.
+ * @param uint64s
+ * The string uint64s array to adjust.
+ *
+ * @return
+ * F_none on success.
+ *
+ * F_memory_not (with error bit) on out of memory.
+ * F_parameter (with error bit) if a parameter is invalid.
+ *
+ * Errors (with error bit) from: f_memory_resize().
+ */
+#ifndef _di_f_type_uint64s_resize_
+ extern f_status_t f_type_uint64s_resize(const f_array_length_t length, f_uint64s_t *uint64s);
+#endif // _di_f_type_uint64s_resize_
+
+/**
+ * Resize the string uint64ss array.
+ *
+ * @param length
+ * The new size to use.
+ * @param uint64ss
+ * The string uint64ss array to resize.
+ *
+ * @return
+ * F_none on success.
+ *
+ * F_memory_not (with error bit) on out of memory.
+ * F_parameter (with error bit) if a parameter is invalid.
+ *
+ * Errors (with error bit) from: f_memory_adjust().
+ * Errors (with error bit) from: f_memory_destroy().
+ */
+#ifndef _di_f_type_uint64ss_adjust_
+ extern f_status_t f_type_uint64ss_adjust(const f_array_length_t length, f_uint64ss_t *uint64ss);
+#endif // _di_f_type_uint64ss_adjust_
+
+/**
+ * Append the source uint64ss onto the destination.
+ *
+ * @param source
+ * The source uint64ss to append.
+ * @param destination
+ * The destination ranges the source is appended onto.
+ *
+ * @return
+ * F_none on success.
+ *
+ * F_memory_not (with error bit) on out of memory.
+ * F_parameter (with error bit) if a parameter is invalid.
+ *
+ * Errors (with error bit) from: f_memory_resize().
+ */
+#ifndef _di_f_type_uint64ss_append_
+ extern f_status_t f_type_uint64ss_append(const f_uint64ss_t source, f_uint64ss_t *destination);
+#endif // _di_f_type_uint64ss_append_
+
+/**
+ * Resize the string uint64ss array.
+ *
+ * @param length
+ * The new size to use.
+ * @param uint64ss
+ * The string uint64ss array to resize.
+ *
+ * @return
+ * F_none on success.
+ *
+ * F_memory_not (with error bit) on out of memory.
+ * F_parameter (with error bit) if a parameter is invalid.
+ *
+ * Errors (with error bit) from: f_memory_adjust().
+ * Errors (with error bit) from: f_memory_destroy().
+ */
+#ifndef _di_f_type_uint64ss_adjust_
+ extern f_status_t f_type_uint64ss_adjust(const f_array_length_t length, f_uint64ss_t *uint64ss);
+#endif // _di_f_type_uint64ss_adjust_
+
+/**
+ * Resize the string uint64ss array to a smaller size.
+ *
+ * This will resize making the array smaller based on (size - given length).
+ * If the given length is too small, then the resize will fail.
+ * This will not shrink the size to less than 0.
+ *
+ * @param amount
+ * A positive number representing how much to decimate the size by.
+ * @param uint64ss
+ * The string uint64ss array to resize.
+ *
+ * @return
+ * F_none on success.
+ *
+ * F_memory_not (with error bit) on out of memory.
+ * F_parameter (with error bit) if a parameter is invalid.
+ *
+ * Errors (with error bit) from: f_memory_adjust().
+ * Errors (with error bit) from: f_memory_destroy().
+ */
+#ifndef _di_f_type_uint64ss_decimate_by_
+ extern f_status_t f_type_uint64ss_decimate_by(const f_array_length_t amount, f_uint64ss_t *uint64ss);
+#endif // _di_f_type_uint64ss_decimate_by_
+
+/**
+ * Resize the string uint64ss array to a smaller size.
*
* This will resize making the array smaller based on (size - given length).
* If the given length is too small, then the resize will fail.
*
* @param amount
* A positive number representing how much to decrease the size by.
- * @param uint32ss
- * The string uint32ss array to resize.
+ * @param uint64ss
+ * The string uint64ss array to resize.
*
* @return
* F_none on success.
*
* F_memory_not (with error bit) on out of memory.
* F_parameter (with error bit) if a parameter is invalid.
+ *
+ * Errors (with error bit) from: f_memory_delete().
+ * Errors (with error bit) from: f_memory_resize().
*/
-#ifndef _di_f_type_uint32ss_decrease_by_
- extern f_status_t f_type_uint32ss_decrease_by(const f_array_length_t amount, f_uint32ss_t *uint32ss);
-#endif // _di_f_type_uint32ss_decrease_by_
+#ifndef _di_f_type_uint64ss_decrease_by_
+ extern f_status_t f_type_uint64ss_decrease_by(const f_array_length_t amount, f_uint64ss_t *uint64ss);
+#endif // _di_f_type_uint64ss_decrease_by_
/**
- * Increase the size of the string uint32ss array, but only if necessary.
+ * Increase the size of the string uint64ss array, but only if necessary.
*
* If the given length is too large for the buffer, then attempt to set max buffer size (f_array_length_t_size).
* If already set to the maximum buffer size, then the resize will fail.
*
- * @param uint32ss
- * The string uint32ss array to resize.
+ * @param uint64ss
+ * The string uint64ss array to resize.
*
* @return
* F_none on success.
* F_array_too_large (with error bit) if the new array length is too large.
* F_memory_not (with error bit) on out of memory.
* F_parameter (with error bit) if a parameter is invalid.
+ *
+ * Errors (with error bit) from: f_memory_resize().
*/
-#ifndef _di_f_type_uint32ss_increase_
- extern f_status_t f_type_uint32ss_increase(f_uint32ss_t *uint32ss);
-#endif // _di_f_type_uint32ss_increase_
+#ifndef _di_f_type_uint64ss_increase_
+ extern f_status_t f_type_uint64ss_increase(f_uint64ss_t *uint64ss);
+#endif // _di_f_type_uint64ss_increase_
/**
- * Resize the string uint32ss array to a larger size.
+ * Resize the string uint64ss array to a larger size.
*
* This will resize making the string larger based on the given length.
* If the given length is too large for the buffer, then attempt to set max buffer size (f_array_length_t_size).
*
* @param amount
* A positive number representing how much to increase the size by.
- * @param uint32ss
- * The string uint32ss array to resize.
+ * @param uint64ss
+ * The string uint64ss array to resize.
*
* @return
* F_none on success.
* F_memory_not (with error bit) on out of memory.
* F_parameter (with error bit) if a parameter is invalid.
* F_array_too_large (with error bit) if the new array length is too large.
+ *
+ * Errors (with error bit) from: f_memory_resize().
*/
-#ifndef _di_f_type_uint32ss_increase_by_
- extern f_status_t f_type_uint32ss_increase_by(const f_array_length_t amount, f_uint32ss_t *uint32ss);
-#endif // _di_f_type_uint32ss_increase_by_
+#ifndef _di_f_type_uint64ss_increase_by_
+ extern f_status_t f_type_uint64ss_increase_by(const f_array_length_t amount, f_uint64ss_t *uint64ss);
+#endif // _di_f_type_uint64ss_increase_by_
+
+/**
+ * Resize the string uint64ss array.
+ *
+ * @param length
+ * The new size to use.
+ * @param uint64ss
+ * The string uint64ss array to adjust.
+ *
+ * @return
+ * F_none on success.
+ *
+ * F_memory_not (with error bit) on out of memory.
+ * F_parameter (with error bit) if a parameter is invalid.
+ *
+ * Errors (with error bit) from: f_memory_delete().
+ * Errors (with error bit) from: f_memory_resize().
+ */
+#ifndef _di_f_type_uint64ss_resize_
+ extern f_status_t f_type_uint64ss_resize(const f_array_length_t length, f_uint64ss_t *uint64ss);
+#endif // _di_f_type_uint64ss_resize_
/**
- * Resize the string uint32ss array.
+ * Resize the string int128s array.
*
* @param length
* The new size to use.
- * @param uint32ss
- * The string uint32ss array to adjust.
+ * @param int128s
+ * The string int128s array to resize.
*
* @return
* F_none on success.
*
- * F_memory_not (with error bit) on out of memory.
* F_parameter (with error bit) if a parameter is invalid.
+ *
+ * Errors (with error bit) from: f_memory_adjust().
*/
-#ifndef _di_f_type_uint32ss_resize_
- extern f_status_t f_type_uint32ss_resize(const f_array_length_t length, f_uint32ss_t *uint32ss);
-#endif // _di_f_type_uint32ss_resize_
+#ifndef _di_f_type_int128s_adjust_
+ extern f_status_t f_type_int128s_adjust(const f_array_length_t length, f_int128s_t *int128s);
+#endif // _di_f_type_int128s_adjust_
/**
- * Resize the string int64ss array.
+ * Append the source int128s onto the destination.
*
- * @param length
- * The new size to use.
- * @param int64ss
- * The string int64ss array to resize.
+ * @param source
+ * The source int128s to append.
+ * @param destination
+ * The destination int128s the source is appended onto.
*
* @return
* F_none on success.
*
- * F_memory_not (with error bit) on out of memory.
* F_parameter (with error bit) if a parameter is invalid.
+ *
+ * Errors (with error bit) from: f_memory_resize().
*/
-#ifndef _di_f_type_int64ss_adjust_
- extern f_status_t f_type_int64ss_adjust(const f_array_length_t length, f_int64ss_t *int64ss);
-#endif // _di_f_type_int64ss_adjust_
+#ifndef _di_f_type_int128s_append_
+ extern f_status_t f_type_int128s_append(const f_int128s_t source, f_int128s_t *destination);
+#endif // _di_f_type_int128s_append_
/**
- * Resize the string int64ss array to a smaller size.
+ * Resize the string int128s array to a smaller size.
*
* This will resize making the array smaller based on (size - given length).
* If the given length is too small, then the resize will fail.
- * This will not shrink the size to less than 0.
+ * This will not shrink the size to les than 0.
*
* @param amount
* A positive number representing how much to decimate the size by.
- * @param int64ss
- * The string int64ss array to resize.
+ * @param int128s
+ * The string int128s array to resize.
*
* @return
* F_none on success.
*
* F_memory_not (with error bit) on out of memory.
* F_parameter (with error bit) if a parameter is invalid.
+ *
+ * Errors (with error bit) from: f_memory_adjust().
*/
-#ifndef _di_f_type_int64ss_decimate_by_
- extern f_status_t f_type_int64ss_decimate_by(const f_array_length_t amount, f_int64ss_t *int64ss);
-#endif // _di_f_type_int64ss_decimate_by_
+#ifndef _di_f_type_int128s_decimate_by_
+ extern f_status_t f_type_int128s_decimate_by(const f_array_length_t amount, f_int128s_t *int128s);
+#endif // _di_f_type_int128s_decimate_by_
/**
- * Resize the string int64ss array to a smaller size.
+ * Resize the string int128s array to a smaller size.
*
* This will resize making the array smaller based on (size - given length).
* If the given length is too small, then the resize will fail.
- * This will not shrink the size to less than 0.
+ * This will not shrink the size to les than 0.
*
* @param amount
* A positive number representing how much to decrease the size by.
- * @param int64ss
- * The string int64ss array to resize.
+ * @param int128s
+ * The string int128s array to resize.
*
* @return
* F_none on success.
*
* F_memory_not (with error bit) on out of memory.
* F_parameter (with error bit) if a parameter is invalid.
+ *
+ * Errors (with error bit) from: f_memory_resize().
*/
-#ifndef _di_f_type_int64ss_decrease_by_
- extern f_status_t f_type_int64ss_decrease_by(const f_array_length_t amount, f_int64ss_t *int64ss);
-#endif // _di_f_type_int64ss_decrease_by_
+#ifndef _di_f_type_int128s_decrease_by_
+ extern f_status_t f_type_int128s_decrease_by(const f_array_length_t amount, f_int128s_t *int128s);
+#endif // _di_f_type_int128s_decrease_by_
/**
- * Increase the size of the string int64ss array, but only if necessary.
+ * Increase the size of the string int128s array, but only if necesary.
*
* If the given length is too large for the buffer, then attempt to set max buffer size (f_array_length_t_size).
* If already set to the maximum buffer size, then the resize will fail.
*
- * @param int64ss
- * The string int64ss array to resize.
+ * @param int128s
+ * The string int128s array to resize.
*
* @return
* F_none on success.
* F_array_too_large (with error bit) if the new array length is too large.
* F_memory_not (with error bit) on out of memory.
* F_parameter (with error bit) if a parameter is invalid.
+ *
+ * Errors (with error bit) from: f_memory_resize().
*/
-#ifndef _di_f_type_int64ss_increase_
- extern f_status_t f_type_int64ss_increase(f_int64ss_t *int64ss);
-#endif // _di_f_type_int64ss_increase_
+#ifndef _di_f_type_int128s_increase_
+ extern f_status_t f_type_int128s_increase(f_int128s_t *int128s);
+#endif // _di_f_type_int128s_increase_
/**
- * Resize the string int64ss array to a larger size.
+ * Resize the string int128s array to a larger size.
*
* This will resize making the string larger based on the given length.
* If the given length is too large for the buffer, then attempt to set max buffer size (f_array_length_t_size).
*
* @param amount
* A positive number representing how much to increase the size by.
- * @param int64ss
- * The string int64ss array to resize.
+ * @param int128s
+ * The string int128s array to resize.
*
* @return
* F_none on success.
* F_memory_not (with error bit) on out of memory.
* F_parameter (with error bit) if a parameter is invalid.
* F_array_too_large (with error bit) if the new array length is too large.
+ *
+ * Errors (with error bit) from: f_memory_resize().
*/
-#ifndef _di_f_type_int64ss_increase_by_
- extern f_status_t f_type_int64ss_increase_by(const f_array_length_t amount, f_int64ss_t *int64ss);
-#endif // _di_f_type_int64ss_increase_by_
+#ifndef _di_f_type_int128s_increase_by_
+ extern f_status_t f_type_int128s_increase_by(const f_array_length_t amount, f_int128s_t *int128s);
+#endif // _di_f_type_int128s_increase_by_
/**
- * Resize the string int64ss array.
+ * Resize the string int128s array.
*
* @param length
* The new size to use.
- * @param int64ss
- * The string int64ss array to adjust.
+ * @param int128s
+ * The string int128s array to adjust.
*
* @return
* F_none on success.
*
* F_memory_not (with error bit) on out of memory.
* F_parameter (with error bit) if a parameter is invalid.
+ *
+ * Errors (with error bit) from: f_memory_resize().
*/
-#ifndef _di_f_type_int64ss_resize_
- extern f_status_t f_type_int64ss_resize(const f_array_length_t length, f_int64ss_t *int64ss);
-#endif // _di_f_type_int64ss_resize_
+#ifndef _di_f_type_int128s_resize_
+ extern f_status_t f_type_int128s_resize(const f_array_length_t length, f_int128s_t *int128s);
+#endif // _di_f_type_int128s_resize_
/**
- * Resize the string uint64ss array.
+ * Resize the string int128ss array.
*
* @param length
* The new size to use.
- * @param uint64ss
- * The string uint64ss array to resize.
+ * @param int128ss
+ * The string int128ss array to resize.
+ *
+ * @return
+ * F_none on success.
+ *
+ * F_memory_not (with error bit) on out of memory.
+ * F_parameter (with error bit) if a parameter is invalid.
+ *
+ * Errors (with error bit) from: f_memory_adjust().
+ * Errors (with error bit) from: f_memory_destroy().
+ */
+#ifndef _di_f_type_int128ss_adjust_
+ extern f_status_t f_type_int128ss_adjust(const f_array_length_t length, f_int128ss_t *int128ss);
+#endif // _di_f_type_int128ss_adjust_
+
+/**
+ * Append the source int128ss onto the destination.
+ *
+ * @param source
+ * The source int128ss to append.
+ * @param destination
+ * The destination ranges the source is appended onto.
*
* @return
* F_none on success.
*
* F_memory_not (with error bit) on out of memory.
* F_parameter (with error bit) if a parameter is invalid.
+ *
+ * Errors (with error bit) from: f_memory_resize().
*/
-#ifndef _di_f_type_uint64ss_adjust_
- extern f_status_t f_type_uint64ss_adjust(const f_array_length_t length, f_uint64ss_t *uint64ss);
-#endif // _di_f_type_uint64ss_adjust_
+#ifndef _di_f_type_int128ss_append_
+ extern f_status_t f_type_int128ss_append(const f_int128ss_t source, f_int128ss_t *destination);
+#endif // _di_f_type_int128ss_append_
/**
- * Resize the string uint64ss array to a smaller size.
+ * Resize the string int128ss array.
+ *
+ * @param length
+ * The new size to use.
+ * @param int128ss
+ * The string int128ss array to resize.
+ *
+ * @return
+ * F_none on success.
+ *
+ * F_memory_not (with error bit) on out of memory.
+ * F_parameter (with error bit) if a parameter is invalid.
+ *
+ * Errors (with error bit) from: f_memory_adjust().
+ * Errors (with error bit) from: f_memory_destroy().
+ */
+#ifndef _di_f_type_int128ss_adjust_
+ extern f_status_t f_type_int128ss_adjust(const f_array_length_t length, f_int128ss_t *int128ss);
+#endif // _di_f_type_int128ss_adjust_
+
+/**
+ * Resize the string int128ss array to a smaller size.
*
* This will resize making the array smaller based on (size - given length).
* If the given length is too small, then the resize will fail.
*
* @param amount
* A positive number representing how much to decimate the size by.
- * @param uint64ss
- * The string uint64ss array to resize.
+ * @param int128ss
+ * The string int128ss array to resize.
*
* @return
* F_none on success.
*
* F_memory_not (with error bit) on out of memory.
* F_parameter (with error bit) if a parameter is invalid.
+ *
+ * Errors (with error bit) from: f_memory_adjust().
+ * Errors (with error bit) from: f_memory_destroy().
*/
-#ifndef _di_f_type_uint64ss_decimate_by_
- extern f_status_t f_type_uint64ss_decimate_by(const f_array_length_t amount, f_uint64ss_t *uint64ss);
-#endif // _di_f_type_uint64ss_decimate_by_
+#ifndef _di_f_type_int128ss_decimate_by_
+ extern f_status_t f_type_int128ss_decimate_by(const f_array_length_t amount, f_int128ss_t *int128ss);
+#endif // _di_f_type_int128ss_decimate_by_
/**
- * Resize the string uint64ss array to a smaller size.
+ * Resize the string int128ss array to a smaller size.
*
* This will resize making the array smaller based on (size - given length).
* If the given length is too small, then the resize will fail.
*
* @param amount
* A positive number representing how much to decrease the size by.
- * @param uint64ss
- * The string uint64ss array to resize.
+ * @param int128ss
+ * The string int128ss array to resize.
*
* @return
* F_none on success.
*
* F_memory_not (with error bit) on out of memory.
* F_parameter (with error bit) if a parameter is invalid.
+ *
+ * Errors (with error bit) from: f_memory_delete().
+ * Errors (with error bit) from: f_memory_resize().
*/
-#ifndef _di_f_type_uint64ss_decrease_by_
- extern f_status_t f_type_uint64ss_decrease_by(const f_array_length_t amount, f_uint64ss_t *uint64ss);
-#endif // _di_f_type_uint64ss_decrease_by_
+#ifndef _di_f_type_int128ss_decrease_by_
+ extern f_status_t f_type_int128ss_decrease_by(const f_array_length_t amount, f_int128ss_t *int128ss);
+#endif // _di_f_type_int128ss_decrease_by_
/**
- * Increase the size of the string uint64ss array, but only if necessary.
+ * Increase the size of the string int128ss array, but only if necessary.
*
* If the given length is too large for the buffer, then attempt to set max buffer size (f_array_length_t_size).
* If already set to the maximum buffer size, then the resize will fail.
*
- * @param uint64ss
- * The string uint64ss array to resize.
+ * @param int128ss
+ * The string int128ss array to resize.
*
* @return
* F_none on success.
* F_array_too_large (with error bit) if the new array length is too large.
* F_memory_not (with error bit) on out of memory.
* F_parameter (with error bit) if a parameter is invalid.
+ *
+ * Errors (with error bit) from: f_memory_resize().
*/
-#ifndef _di_f_type_uint64ss_increase_
- extern f_status_t f_type_uint64ss_increase(f_uint64ss_t *uint64ss);
-#endif // _di_f_type_uint64ss_increase_
+#ifndef _di_f_type_int128ss_increase_
+ extern f_status_t f_type_int128ss_increase(f_int128ss_t *int128ss);
+#endif // _di_f_type_int128ss_increase_
/**
- * Resize the string uint64ss array to a larger size.
+ * Resize the string int128ss array to a larger size.
*
* This will resize making the string larger based on the given length.
* If the given length is too large for the buffer, then attempt to set max buffer size (f_array_length_t_size).
*
* @param amount
* A positive number representing how much to increase the size by.
- * @param uint64ss
- * The string uint64ss array to resize.
+ * @param int128ss
+ * The string int128ss array to resize.
*
* @return
* F_none on success.
* F_memory_not (with error bit) on out of memory.
* F_parameter (with error bit) if a parameter is invalid.
* F_array_too_large (with error bit) if the new array length is too large.
+ *
+ * Errors (with error bit) from: f_memory_resize().
*/
-#ifndef _di_f_type_uint64ss_increase_by_
- extern f_status_t f_type_uint64ss_increase_by(const f_array_length_t amount, f_uint64ss_t *uint64ss);
-#endif // _di_f_type_uint64ss_increase_by_
+#ifndef _di_f_type_int128ss_increase_by_
+ extern f_status_t f_type_int128ss_increase_by(const f_array_length_t amount, f_int128ss_t *int128ss);
+#endif // _di_f_type_int128ss_increase_by_
/**
- * Resize the string uint64ss array.
+ * Resize the string int128ss array.
*
* @param length
* The new size to use.
- * @param uint64ss
- * The string uint64ss array to adjust.
+ * @param int128ss
+ * The string int128ss array to adjust.
*
* @return
* F_none on success.
*
* F_memory_not (with error bit) on out of memory.
* F_parameter (with error bit) if a parameter is invalid.
+ *
+ * Errors (with error bit) from: f_memory_delete().
+ * Errors (with error bit) from: f_memory_resize().
*/
-#ifndef _di_f_type_uint64ss_resize_
- extern f_status_t f_type_uint64ss_resize(const f_array_length_t length, f_uint64ss_t *uint64ss);
-#endif // _di_f_type_uint64ss_resize_
+#ifndef _di_f_type_int128ss_resize_
+ extern f_status_t f_type_int128ss_resize(const f_array_length_t length, f_int128ss_t *int128ss);
+#endif // _di_f_type_int128ss_resize_
/**
- * Resize the string int128ss array.
+ * Resize the string uint128s array.
*
* @param length
* The new size to use.
- * @param int128ss
- * The string int128ss array to resize.
+ * @param uint128s
+ * The string uint128s array to resize.
*
* @return
* F_none on success.
*
- * F_memory_not (with error bit) on out of memory.
* F_parameter (with error bit) if a parameter is invalid.
+ *
+ * Errors (with error bit) from: f_memory_adjust().
*/
-#ifndef _di_f_type_int128ss_adjust_
- extern f_status_t f_type_int128ss_adjust(const f_array_length_t length, f_int128ss_t *int128ss);
-#endif // _di_f_type_int128ss_adjust_
+#ifndef _di_f_type_uint128s_adjust_
+ extern f_status_t f_type_uint128s_adjust(const f_array_length_t length, f_uint128s_t *uint128s);
+#endif // _di_f_type_uint128s_adjust_
/**
- * Resize the string int128ss array to a smaller size.
+ * Append the source uint128s onto the destination.
+ *
+ * @param source
+ * The source uint128s to append.
+ * @param destination
+ * The destination uint128s the source is appended onto.
+ *
+ * @return
+ * F_none on success.
+ *
+ * F_parameter (with error bit) if a parameter is invalid.
+ *
+ * Errors (with error bit) from: f_memory_resize().
+ */
+#ifndef _di_f_type_uint128s_append_
+ extern f_status_t f_type_uint128s_append(const f_uint128s_t source, f_uint128s_t *destination);
+#endif // _di_f_type_uint128s_append_
+
+/**
+ * Resize the string uint128s array to a smaller size.
*
* This will resize making the array smaller based on (size - given length).
* If the given length is too small, then the resize will fail.
- * This will not shrink the size to less than 0.
+ * This will not shrink the size to les than 0.
*
* @param amount
* A positive number representing how much to decimate the size by.
- * @param int128ss
- * The string int128ss array to resize.
+ * @param uint128s
+ * The string uint128s array to resize.
*
* @return
* F_none on success.
*
* F_memory_not (with error bit) on out of memory.
* F_parameter (with error bit) if a parameter is invalid.
+ *
+ * Errors (with error bit) from: f_memory_adjust().
*/
-#ifndef _di_f_type_int128ss_decimate_by_
- extern f_status_t f_type_int128ss_decimate_by(const f_array_length_t amount, f_int128ss_t *int128ss);
-#endif // _di_f_type_int128ss_decimate_by_
+#ifndef _di_f_type_uint128s_decimate_by_
+ extern f_status_t f_type_uint128s_decimate_by(const f_array_length_t amount, f_uint128s_t *uint128s);
+#endif // _di_f_type_uint128s_decimate_by_
/**
- * Resize the string int128ss array to a smaller size.
+ * Resize the string uint128s array to a smaller size.
*
* This will resize making the array smaller based on (size - given length).
* If the given length is too small, then the resize will fail.
- * This will not shrink the size to less than 0.
+ * This will not shrink the size to les than 0.
*
* @param amount
* A positive number representing how much to decrease the size by.
- * @param int128ss
- * The string int128ss array to resize.
+ * @param uint128s
+ * The string uint128s array to resize.
*
* @return
* F_none on success.
*
* F_memory_not (with error bit) on out of memory.
* F_parameter (with error bit) if a parameter is invalid.
+ *
+ * Errors (with error bit) from: f_memory_resize().
*/
-#ifndef _di_f_type_int128ss_decrease_by_
- extern f_status_t f_type_int128ss_decrease_by(const f_array_length_t amount, f_int128ss_t *int128ss);
-#endif // _di_f_type_int128ss_decrease_by_
+#ifndef _di_f_type_uint128s_decrease_by_
+ extern f_status_t f_type_uint128s_decrease_by(const f_array_length_t amount, f_uint128s_t *uint128s);
+#endif // _di_f_type_uint128s_decrease_by_
/**
- * Increase the size of the string int128ss array, but only if necessary.
+ * Increase the size of the string uint128s array, but only if necesary.
*
* If the given length is too large for the buffer, then attempt to set max buffer size (f_array_length_t_size).
* If already set to the maximum buffer size, then the resize will fail.
*
- * @param int128ss
- * The string int128ss array to resize.
+ * @param uint128s
+ * The string uint128s array to resize.
*
* @return
* F_none on success.
* F_array_too_large (with error bit) if the new array length is too large.
* F_memory_not (with error bit) on out of memory.
* F_parameter (with error bit) if a parameter is invalid.
+ *
+ * Errors (with error bit) from: f_memory_resize().
*/
-#ifndef _di_f_type_int128ss_increase_
- extern f_status_t f_type_int128ss_increase(f_int128ss_t *int128ss);
-#endif // _di_f_type_int128ss_increase_
+#ifndef _di_f_type_uint128s_increase_
+ extern f_status_t f_type_uint128s_increase(f_uint128s_t *uint128s);
+#endif // _di_f_type_uint128s_increase_
/**
- * Resize the string int128ss array to a larger size.
+ * Resize the string uint128s array to a larger size.
*
* This will resize making the string larger based on the given length.
* If the given length is too large for the buffer, then attempt to set max buffer size (f_array_length_t_size).
*
* @param amount
* A positive number representing how much to increase the size by.
- * @param int128ss
- * The string int128ss array to resize.
+ * @param uint128s
+ * The string uint128s array to resize.
*
* @return
* F_none on success.
* F_memory_not (with error bit) on out of memory.
* F_parameter (with error bit) if a parameter is invalid.
* F_array_too_large (with error bit) if the new array length is too large.
+ *
+ * Errors (with error bit) from: f_memory_resize().
*/
-#ifndef _di_f_type_int128ss_increase_by_
- extern f_status_t f_type_int128ss_increase_by(const f_array_length_t amount, f_int128ss_t *int128ss);
-#endif // _di_f_type_int128ss_increase_by_
+#ifndef _di_f_type_uint128s_increase_by_
+ extern f_status_t f_type_uint128s_increase_by(const f_array_length_t amount, f_uint128s_t *uint128s);
+#endif // _di_f_type_uint128s_increase_by_
/**
- * Resize the string int128ss array.
+ * Resize the string uint128s array.
*
* @param length
* The new size to use.
- * @param int128ss
- * The string int128ss array to adjust.
+ * @param uint128s
+ * The string uint128s array to adjust.
*
* @return
* F_none on success.
*
* F_memory_not (with error bit) on out of memory.
* F_parameter (with error bit) if a parameter is invalid.
+ *
+ * Errors (with error bit) from: f_memory_resize().
*/
-#ifndef _di_f_type_int128ss_resize_
- extern f_status_t f_type_int128ss_resize(const f_array_length_t length, f_int128ss_t *int128ss);
-#endif // _di_f_type_int128ss_resize_
+#ifndef _di_f_type_uint128s_resize_
+ extern f_status_t f_type_uint128s_resize(const f_array_length_t length, f_uint128s_t *uint128s);
+#endif // _di_f_type_uint128s_resize_
+
+/**
+ * Resize the string uint128ss array.
+ *
+ * @param length
+ * The new size to use.
+ * @param uint128ss
+ * The string uint128ss array to resize.
+ *
+ * @return
+ * F_none on success.
+ *
+ * F_memory_not (with error bit) on out of memory.
+ * F_parameter (with error bit) if a parameter is invalid.
+ *
+ * Errors (with error bit) from: f_memory_adjust().
+ * Errors (with error bit) from: f_memory_destroy().
+ */
+#ifndef _di_f_type_uint128ss_adjust_
+ extern f_status_t f_type_uint128ss_adjust(const f_array_length_t length, f_uint128ss_t *uint128ss);
+#endif // _di_f_type_uint128ss_adjust_
+
+/**
+ * Append the source uint128ss onto the destination.
+ *
+ * @param source
+ * The source uint128ss to append.
+ * @param destination
+ * The destination ranges the source is appended onto.
+ *
+ * @return
+ * F_none on success.
+ *
+ * F_memory_not (with error bit) on out of memory.
+ * F_parameter (with error bit) if a parameter is invalid.
+ *
+ * Errors (with error bit) from: f_memory_resize().
+ */
+#ifndef _di_f_type_uint128ss_append_
+ extern f_status_t f_type_uint128ss_append(const f_uint128ss_t source, f_uint128ss_t *destination);
+#endif // _di_f_type_uint128ss_append_
/**
* Resize the string uint128ss array.
*
* F_memory_not (with error bit) on out of memory.
* F_parameter (with error bit) if a parameter is invalid.
+ *
+ * Errors (with error bit) from: f_memory_adjust().
+ * Errors (with error bit) from: f_memory_destroy().
*/
#ifndef _di_f_type_uint128ss_adjust_
extern f_status_t f_type_uint128ss_adjust(const f_array_length_t length, f_uint128ss_t *uint128ss);
*
* F_memory_not (with error bit) on out of memory.
* F_parameter (with error bit) if a parameter is invalid.
+ *
+ * Errors (with error bit) from: f_memory_adjust().
+ * Errors (with error bit) from: f_memory_destroy().
*/
#ifndef _di_f_type_uint128ss_decimate_by_
extern f_status_t f_type_uint128ss_decimate_by(const f_array_length_t amount, f_uint128ss_t *uint128ss);
*
* F_memory_not (with error bit) on out of memory.
* F_parameter (with error bit) if a parameter is invalid.
+ *
+ * Errors (with error bit) from: f_memory_delete().
+ * Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_type_uint128ss_decrease_by_
extern f_status_t f_type_uint128ss_decrease_by(const f_array_length_t amount, f_uint128ss_t *uint128ss);
* F_array_too_large (with error bit) if the new array length is too large.
* F_memory_not (with error bit) on out of memory.
* F_parameter (with error bit) if a parameter is invalid.
+ *
+ * Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_type_uint128ss_increase_
extern f_status_t f_type_uint128ss_increase(f_uint128ss_t *uint128ss);
* F_memory_not (with error bit) on out of memory.
* F_parameter (with error bit) if a parameter is invalid.
* F_array_too_large (with error bit) if the new array length is too large.
+ *
+ * Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_type_uint128ss_increase_by_
extern f_status_t f_type_uint128ss_increase_by(const f_array_length_t amount, f_uint128ss_t *uint128ss);
*
* F_memory_not (with error bit) on out of memory.
* F_parameter (with error bit) if a parameter is invalid.
+ *
+ * Errors (with error bit) from: f_memory_delete().
+ * Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_type_uint128ss_resize_
extern f_status_t f_type_uint128ss_resize(const f_array_length_t length, f_uint128ss_t *uint128ss);
projects / fll / commitdiff