build_libraries-level
build_libraries-level_threadless
build_sources_library account.c private-account.c capability.c color.c color-common.c console.c console-common.c control_group.c control_group-common.c conversion.c directory.c private-directory.c environment.c private-environment.c file.c file-common.c private-file.c fss.c private-fss.c fss_named.c fss_nest.c fss_set.c iki.c iki-common.c private-iki.c limit.c memory.c memory_structure.c private-memory.c path.c path-common.c private-path.c pipe.c print.c private-print.c serialize.c serialize-common.c private-serialize.c signal.c socket.c string.c string-common.c private-string.c string_dynamic.c string_map.c string_quantity.c string_range.c string_triple.c type_array.c private-type_array.c utf.c utf-common.c private-utf.c utf_dynamic.c utf_map.c utf_quantity.c utf_range.c utf_triple.c
-build_sources_library-level thread.c
+build_sources_library-level thread.c private-thread.c
build_sources_program
build_sources_headers account.h account-common.h capability.h capability-common.h color.h color-common.h console.h console-common.h control_group.h control_group-common.h conversion.h conversion-common.h directory.h directory_type.h directory-common.h environment.h environment-common.h execute.h execute-common.h file.h file-common.h fss.h private-fss.h fss-common.h fss_comment.h fss_delimit.h fss_named.h fss_nest.h fss_quote.h fss_set.h iki.h iki-common.h limit.h limit-common.h memory.h memory_structure.h memory-common.h path.h path-common.h pipe.h print.h serialize.h serialize-common.h signal.h signal-common.h socket.h socket-common.h status.h status_array.h string.h string-common.h private-string.h string_dynamic.h string_map.h string_quantity.h string_range.h string_triple.h type.h type_array.h private-type_array.h type_array-common.h utf.h utf-common.h utf_dynamic.h utf_map.h utf_quantity.h utf_range.h utf_triple.h
build_sources_headers-level thread.h thread-common.h
build_libraries-monolithic
build_libraries-monolithic_threadless
build_sources_library level_0/account.c level_0/private-account.c level_0/capability.c level_0/color.c level_0/color-common.c level_0/console.c level_0/console-common.c level_0/control_group.c level_0/control_group-common.c level_0/conversion.c level_0/directory.c level_0/private-directory.c level_0/environment.c level_0/private-environment.c level_0/file.c level_0/file-common.c level_0/private-file.c level_0/fss.c level_0/private-fss.c level_0/fss_named.c level_0/fss_nest.c level_0/fss_set.c level_0/iki.c level_0/iki-common.c level_0/private-iki.c level_0/limit.c level_0/memory.c level_0/memory_structure.c level_0/private-memory.c level_0/path.c level_0/path-common.c level_0/private-path.c level_0/pipe.c level_0/print.c level_0/private-print.c level_0/serialize.c level_0/serialize-common.c level_0/private-serialize.c level_0/signal.c level_0/socket.c level_0/string.c level_0/string-common.c level_0/private-string.c level_0/string_dynamic.c level_0/string_map.c level_0/string_quantity.c level_0/string_range.c level_0/string_triple.c level_0/type_array.c level_0/private-type_array.c level_0/utf.c level_0/utf-common.c level_0/private-utf.c level_0/utf_dynamic.c level_0/utf_map.c level_0/utf_quantity.c level_0/utf_range.c level_0/utf_triple.c level_1/color.c level_1/console.c level_1/control_group.c level_1/conversion.c level_1/directory.c level_1/private-directory.c level_1/environment.c level_1/private-fss.c level_1/fss_basic.c level_1/fss_basic_list.c level_1/fss_embedded_list.c level_1/fss_extended.c level_1/fss_extended_list.c level_1/iki.c level_1/print.c level_1/private-print.c level_1/status.c level_1/string.c level_1/private-string.c level_1/utf.c level_1/private-utf.c level_1/utf_file.c level_1/private-utf_file.c level_2/control_group.c level_2/error.c level_2/error-common.c level_2/private-error.c level_2/execute.c level_2/private-execute.c level_2/file.c level_2/private-file.c level_2/fss.c level_2/private-fss.c level_2/fss_basic.c level_2/fss_basic_list.c level_2/fss_embedded_list.c level_2/fss_extended.c level_2/fss_extended_list.c level_2/fss_status.c level_2/iki.c level_2/private-iki.c level_2/path.c level_2/program.c level_2/status.c
-build_sources_library-monolithic level_0/thread.c
+build_sources_library-monolithic level_0/thread.c level_0/private-thread.c
build_sources_program
build_sources_headers level_0/account.h level_0/account-common.h level_0/capability.h level_0/capability-common.h level_0/color.h level_0/color-common.h level_0/console.h level_0/console-common.h level_0/control_group.h level_0/control_group-common.h level_0/conversion.h level_0/conversion-common.h level_0/directory.h level_0/directory_type.h level_0/directory-common.h level_0/environment.h level_0/environment-common.h level_0/execute.h level_0/execute-common.h level_0/file.h level_0/file-common.h level_0/fss.h level_0/private-fss.h level_0/fss-common.h level_0/fss_comment.h level_0/fss_delimit.h level_0/fss_named.h level_0/fss_nest.h level_0/fss_quote.h level_0/fss_set.h level_0/iki.h level_0/iki-common.h level_0/limit.h level_0/limit-common.h level_0/memory.h level_0/memory_structure.h level_0/memory-common.h level_0/path.h level_0/path-common.h level_0/pipe.h level_0/print.h level_0/serialize.h level_0/serialize-common.h level_0/signal.h level_0/signal-common.h level_0/socket.h level_0/socket-common.h level_0/status.h level_0/status_array.h level_0/string.h level_0/string-common.h level_0/private-string.h level_0/string_dynamic.h level_0/string_map.h level_0/string_quantity.h level_0/string_range.h level_0/string_triple.h level_0/type.h level_0/type_array.h level_0/private-type_array.h level_0/type_array-common.h level_0/utf.h level_0/utf-common.h level_0/utf_dynamic.h level_0/utf_map.h level_0/utf_quantity.h level_0/utf_range.h level_0/utf_triple.h level_1/color.h level_1/console.h level_1/control_group.h level_1/conversion.h level_1/directory.h level_1/environment.h level_1/execute.h level_1/execute-common.h level_1/fss.h level_1/fss_basic.h level_1/fss_basic_list.h level_1/fss_embedded_list.h level_1/fss_extended.h level_1/fss_extended_list.h level_1/fss_status.h level_1/iki.h level_1/print.h level_1/status.h level_1/string.h level_1/utf.h level_1/utf_file.h level_2/control_group.h level_2/error.h level_2/error-common.h level_2/execute.h level_2/file.h level_2/fss.h level_2/fss_basic.h level_2/fss_basic_list.h level_2/fss_embedded_list.h level_2/fss_extended.h level_2/fss_extended_list.h level_2/fss_status.h level_2/iki.h level_2/path.h level_2/program.h level_2/status.h
build_sources_headers-monolithic level_0/thread.h level_0/thread-common.h
--- /dev/null
+#include "thread.h"
+#include "private-thread.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#if !defined(_di_f_thread_attributes_adjust_) || !defined(_di_f_thread_attributes_decimate_by_) || !defined(_di_f_thread_attributes_decrease_) || !defined(_di_f_thread_attributes_decrease_by_) || !defined(_di_f_thread_attributes_increase_) || !defined(_di_f_thread_attributes_increase_by_) || !defined(_di_f_thread_attributes_resize_) || !defined(_di_f_thread_sets_adjust_) || !defined(_di_f_thread_sets_decimate_by_) || !defined(_di_f_thread_sets_decrease_) || !defined(_di_f_thread_sets_decrease_by_) || !defined(_di_f_thread_sets_increase_) || !defined(_di_f_thread_sets_increase_by_) || !defined(_di_f_thread_sets_resize_)
+ f_status_t private_f_thread_attribute_delete(f_thread_attribute_t *attribute) {
+
+ if (pthread_attr_destroy(attribute)) {
+ return F_status_set_error(F_failure);
+ }
+
+ attribute = 0;
+
+ return F_none;
+ }
+#endif // !defined(_di_f_thread_attributes_adjust_) || !defined(_di_f_thread_attributes_decimate_by_) || !defined(_di_f_thread_attributes_decrease_) || !defined(_di_f_thread_attributes_decrease_by_) || !defined(_di_f_thread_attributes_increase_) || !defined(_di_f_thread_attributes_increase_by_) || !defined(_di_f_thread_attributes_resize_) || !defined(_di_f_thread_sets_adjust_) || !defined(_di_f_thread_sets_decimate_by_) || !defined(_di_f_thread_sets_decrease_) || !defined(_di_f_thread_sets_decrease_by_) || !defined(_di_f_thread_sets_increase_) || !defined(_di_f_thread_sets_increase_by_) || !defined(_di_f_thread_sets_resize_)
+
+#if !defined(_di_f_thread_attributes_adjust_) || !defined(_di_f_thread_attributes_decimate_by_)
+ f_status_t private_f_thread_attributes_adjust(const f_array_length_t length, f_thread_attributes_t *attributes) {
+ f_status_t status = F_none;
+
+ for (f_array_length_t i = length; i < attributes->size; ++i) {
+
+ status = private_f_thread_attribute_delete(&attributes->array[i]);
+ if (F_status_is_error(status)) return status;
+ } // for
+
+ status = f_memory_adjust(attributes->size, length, sizeof(f_thread_attribute_t), (void **) & attributes->array);
+
+ if (F_status_is_error_not(status)) {
+ attributes->size = length;
+
+ if (attributes->used > attributes->size) {
+ attributes->used = length;
+ }
+ }
+
+ return status;
+ }
+#endif // !defined(_di_f_thread_attributes_adjust_) || !defined(_di_f_thread_attributes_decimate_by_)
+
+#if !defined(_di_f_thread_attributes_decrease_) || !defined(_di_f_thread_attributes_decrease_by_) || !defined(_di_f_thread_attributes_increase_) || !defined(_di_f_thread_attributes_increase_by_)
+ f_status_t private_f_thread_attributes_resize(const f_array_length_t length, f_thread_attributes_t *attributes) {
+ f_status_t status = F_none;
+
+ for (f_array_length_t i = length; i < attributes->size; ++i) {
+
+ status = private_f_thread_attribute_delete(&attributes->array[i]);
+ if (F_status_is_error(status)) return status;
+ } // for
+
+ status = f_memory_resize(attributes->size, length, sizeof(f_thread_attribute_t), (void **) & attributes->array);
+
+ if (F_status_is_error_not(status)) {
+ attributes->size = length;
+
+ if (attributes->used > attributes->size) {
+ attributes->used = length;
+ }
+ }
+
+ return status;
+ }
+#endif // !defined(_di_f_thread_attributes_decrease_) || !defined(_di_f_thread_attributes_decrease_by_) || !defined(_di_f_thread_attributes_increase_) || !defined(_di_f_thread_attributes_increase_by_)
+
+#if !defined(_di_f_thread_mutexs_adjust_) || !defined(_di_f_thread_mutexs_decimate_by_) || !defined(_di_f_thread_mutexs_decrease_) || !defined(_di_f_thread_mutexs_decrease_by_) || !defined(_di_f_thread_mutexs_increase_) || !defined(_di_f_thread_mutexs_increase_by_) || !defined(_di_f_thread_mutexs_resize_)
+ f_status_t private_f_thread_mutex_delete(f_thread_mutex_t *mutex) {
+
+ const int error = pthread_mutex_destroy(mutex);
+
+ if (error) {
+ if (error == EBUSY) return F_status_set_error(F_busy);
+ if (error == EINVAL) return F_status_set_error(F_parameter);
+
+ return F_status_set_error(F_failure);
+ }
+
+ return F_none;
+ }
+#endif // !defined(_di_f_thread_mutexs_adjust_) || !defined(_di_f_thread_mutexs_decimate_by_) || !defined(_di_f_thread_mutexs_decrease_) || !defined(_di_f_thread_mutexs_decrease_by_) || !defined(_di_f_thread_mutexs_increase_) || !defined(_di_f_thread_mutexs_increase_by_) || !defined(_di_f_thread_mutexs_resize_)
+
+#if !defined(_di_f_thread_mutexs_adjust_) || !defined(_di_f_thread_mutexs_decimate_by_)
+ f_status_t private_f_thread_mutexs_adjust(const f_array_length_t length, f_thread_mutexs_t *mutexs) {
+ f_status_t status = F_none;
+
+ for (f_array_length_t i = length; i < mutexs->size; ++i) {
+
+ status = private_f_thread_mutex_delete(&mutexs->array[i]);
+ if (F_status_is_error(status)) return status;
+ } // for
+
+ status = f_memory_adjust(mutexs->size, length, sizeof(f_thread_mutex_t), (void **) & mutexs->array);
+
+ if (F_status_is_error_not(status)) {
+ mutexs->size = length;
+
+ if (mutexs->used > mutexs->size) {
+ mutexs->used = length;
+ }
+ }
+
+ return status;
+ }
+#endif // !defined(_di_f_thread_mutexs_adjust_) || !defined(_di_f_thread_mutexs_decimate_by_)
+
+#if !defined(_di_f_thread_mutexs_decrease_) || !defined(_di_f_thread_mutexs_decrease_by_) || !defined(_di_f_thread_mutexs_increase_) || !defined(_di_f_thread_mutexs_increase_by_)
+ f_status_t private_f_thread_mutexs_resize(const f_array_length_t length, f_thread_mutexs_t *mutexs) {
+ f_status_t status = F_none;
+
+ for (f_array_length_t i = length; i < mutexs->size; ++i) {
+
+ status = private_f_thread_mutex_delete(&mutexs->array[i]);
+ if (F_status_is_error(status)) return status;
+ } // for
+
+ status = f_memory_resize(mutexs->size, length, sizeof(f_thread_mutex_t), (void **) & mutexs->array);
+
+ if (F_status_is_error_not(status)) {
+ mutexs->size = length;
+
+ if (mutexs->used > mutexs->size) {
+ mutexs->used = length;
+ }
+ }
+
+ return status;
+ }
+#endif // !defined(_di_f_thread_mutexs_decrease_) || !defined(_di_f_thread_mutexs_decrease_by_) || !defined(_di_f_thread_mutexs_increase_) || !defined(_di_f_thread_mutexs_increase_by_)
+
+#if !defined(_di_f_thread_sets_adjust_) || !defined(_di_f_thread_sets_decimate_by_)
+ f_status_t private_f_thread_sets_adjust(const f_array_length_t length, f_thread_sets_t *sets) {
+ f_status_t status = F_none;
+
+ for (f_array_length_t i = length; i < sets->size; ++i) {
+
+ status = private_f_thread_attribute_delete(&sets->array[i].attribute);
+ if (F_status_is_error(status)) return status;
+ } // for
+
+ status = f_memory_adjust(sets->size, length, sizeof(f_thread_set_t), (void **) & sets->array);
+
+ if (F_status_is_error_not(status)) {
+ sets->size = length;
+
+ if (sets->used > sets->size) {
+ sets->used = length;
+ }
+ }
+
+ return status;
+ }
+#endif // !defined(_di_f_thread_sets_adjust_) || !defined(_di_f_thread_sets_decimate_by_)
+
+#if !defined(_di_f_thread_sets_decrease_) || !defined(_di_f_thread_sets_decrease_by_) || !defined(_di_f_thread_sets_increase_) || !defined(_di_f_thread_sets_increase_by_)
+ f_status_t private_f_thread_sets_resize(const f_array_length_t length, f_thread_sets_t *sets) {
+ f_status_t status = F_none;
+
+ for (f_array_length_t i = length; i < sets->size; ++i) {
+
+ status = private_f_thread_attribute_delete(&sets->array[i].attribute);
+ if (F_status_is_error(status)) return status;
+ } // for
+
+ status = f_memory_resize(sets->size, length, sizeof(f_thread_set_t), (void **) & sets->array);
+
+ if (F_status_is_error_not(status)) {
+ sets->size = length;
+
+ if (sets->used > sets->size) {
+ sets->used = length;
+ }
+ }
+
+ return status;
+ }
+#endif // !defined(_di_f_thread_sets_decrease_) || !defined(_di_f_thread_sets_decrease_by_) || !defined(_di_f_thread_sets_increase_) || !defined(_di_f_thread_sets_increase_by_)
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
--- /dev/null
+/**
+ * FLL - Level 0
+ *
+ * Project: Thread
+ * API Version: 0.5
+ * Licenses: lgplv2.1
+ *
+ * These are provided for internal reduction in redundant code.
+ * These should not be exposed/used outside of this project.
+ */
+#ifndef _PRIVATE_F_thread_h
+#define _PRIVATE_F_thread_h
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * Private implementation for deleting (and destroying).
+ *
+ * Intended to be shared to each of the different implementation variations.
+ *
+ * @param length
+ * The new size to use.
+ * @param attributes
+ * The attributes to adjust.
+ *
+ * @return
+ * F_none on success.
+ *
+ * F_failure (with error bit) on error.
+ *
+ * @see f_thread_attributes_adjust()
+ * @see f_thread_attributes_decimate_by()
+ * @see f_thread_attributes_decrease()
+ * @see f_thread_attributes_decrease_by()
+ * @see f_thread_attributes_increase()
+ * @see f_thread_attributes_increase_by()
+ * @see f_thread_attributes_resize()
+ * @see f_thread_sets_adjust()
+ * @see f_thread_sets_decimate_by()
+ * @see f_thread_sets_decrease()
+ * @see f_thread_sets_decrease_by()
+ * @see f_thread_sets_increase()
+ * @see f_thread_sets_increase_by()
+ * @see f_thread_sets_resize()
+ */
+#if !defined(_di_f_thread_attributes_adjust_) || !defined(_di_f_thread_attributes_decimate_by_) || !defined(_di_f_thread_attributes_decrease_) || !defined(_di_f_thread_attributes_decrease_by_) || !defined(_di_f_thread_attributes_increase_) || !defined(_di_f_thread_attributes_increase_by_) || !defined(_di_f_thread_attributes_resize_) || !defined(_di_f_thread_sets_adjust_) || !defined(_di_f_thread_sets_decimate_by_) || !defined(_di_f_thread_sets_decrease_) || !defined(_di_f_thread_sets_decrease_by_) || !defined(_di_f_thread_sets_increase_) || !defined(_di_f_thread_sets_increase_by_) || !defined(_di_f_thread_sets_resize_)
+ extern f_status_t private_f_thread_attribute_delete(f_thread_attribute_t *attribute) f_gcc_attribute_visibility_internal;
+#endif // !defined(_di_f_thread_attributes_adjust_) || !defined(_di_f_thread_attributes_decimate_by_) || !defined(_di_f_thread_attributes_decrease_) || !defined(_di_f_thread_attributes_decrease_by_) || !defined(_di_f_thread_attributes_increase_) || !defined(_di_f_thread_attributes_increase_by_) || !defined(_di_f_thread_sets_adjust_) || !defined(_di_f_thread_sets_decimate_by_) || !defined(_di_f_thread_sets_decrease_) || !defined(_di_f_thread_sets_decrease_by_) || !defined(_di_f_thread_sets_increase_) || !defined(_di_f_thread_sets_increase_by_)
+
+/**
+ * Private implementation for resizing.
+ *
+ * Intended to be shared to each of the different implementation variations.
+ *
+ * @param length
+ * The new size to use.
+ * @param attributes
+ * The attributes to adjust.
+ *
+ * @return
+ * F_none on success.
+ *
+ * Errors (with error bit) from: f_memory_adjust().
+ *
+ * @see f_memory_adjust()
+ * @see f_thread_attributes_adjust()
+ * @see f_thread_attributes_decimate_by()
+ */
+#if !defined(_di_f_thread_attributes_adjust_) || !defined(_di_f_thread_attributes_decimate_by_)
+ extern f_status_t private_f_thread_attributes_adjust(const f_array_length_t length, f_thread_attributes_t *attributes) f_gcc_attribute_visibility_internal;
+#endif // !defined(_di_f_thread_attributes_adjust_) || !defined(_di_f_thread_attributes_decimate_by_)
+
+/**
+ * Private implementation for resizing.
+ *
+ * Intended to be shared to each of the different implementation variations.
+ *
+ * @param length
+ * The new size to use.
+ * @param attributes
+ * The attributes to resize.
+ *
+ * @return
+ * F_none on success.
+ *
+ * Errors (with error bit) from: f_memory_resize().
+ *
+ * @see f_memory_resize()
+ * @see f_thread_attributes_decrease_by()
+ * @see f_thread_attributes_increase()
+ * @see f_thread_attributes_increase_by()
+ */
+#if !defined(_di_f_thread_attributes_decrease_by_) || !defined(_di_f_thread_attributes_increase_) || !defined(_di_f_thread_attributes_increase_by_)
+ extern f_status_t private_f_thread_attributes_resize(const f_array_length_t length, f_thread_attributes_t *attributes) f_gcc_attribute_visibility_internal;
+#endif // !defined(_di_f_thread_attributes_decrease_by_) || !defined(_di_f_thread_attributes_increase_) || !defined(_di_f_thread_attributes_increase_by_)
+
+/**
+ * Private implementation for deleting (and destroying).
+ *
+ * Intended to be shared to each of the different implementation variations.
+ *
+ * @param length
+ * The new size to use.
+ * @param mutexs
+ * The mutexs to adjust.
+ *
+ * @return
+ * F_none on success.
+ *
+ * F_failure (with error bit) on error.
+ *
+ * @see f_thread_mutexs_adjust()
+ * @see f_thread_mutexs_decimate_by()
+ * @see f_thread_mutexs_decrease()
+ * @see f_thread_mutexs_decrease_by()
+ * @see f_thread_mutexs_increase()
+ * @see f_thread_mutexs_increase_by()
+ * @see f_thread_mutexs_resize()
+ */
+#if !defined(_di_f_thread_mutexs_adjust_) || !defined(_di_f_thread_mutexs_decimate_by_) || !defined(_di_f_thread_mutexs_decrease_) || !defined(_di_f_thread_mutexs_decrease_by_) || !defined(_di_f_thread_mutexs_increase_) || !defined(_di_f_thread_mutexs_increase_by_) || !defined(_di_f_thread_mutexs_resize_)
+ extern f_status_t private_f_thread_mutex_delete(f_thread_mutex_t *mutex) f_gcc_attribute_visibility_internal;
+#endif // !defined(_di_f_thread_mutexs_adjust_) || !defined(_di_f_thread_mutexs_decimate_by_) || !defined(_di_f_thread_mutexs_decrease_) || !defined(_di_f_thread_mutexs_decrease_by_) || !defined(_di_f_thread_mutexs_increase_) || !defined(_di_f_thread_mutexs_increase_by_) || !defined(_di_f_thread_mutexs_resize_)
+
+/**
+ * Private implementation for resizing.
+ *
+ * Intended to be shared to each of the different implementation variations.
+ *
+ * @param length
+ * The new size to use.
+ * @param mutexs
+ * The mutexs to adjust.
+ *
+ * @return
+ * F_none on success.
+ *
+ * Errors (with error bit) from: f_memory_adjust().
+ *
+ * @see f_memory_adjust()
+ * @see f_thread_mutexs_adjust()
+ * @see f_thread_mutexs_decimate_by()
+ */
+#if !defined(_di_f_thread_mutexs_adjust_) || !defined(_di_f_thread_mutexs_decimate_by_)
+ extern f_status_t private_f_thread_mutexs_adjust(const f_array_length_t length, f_thread_mutexs_t *mutexs) f_gcc_attribute_visibility_internal;
+#endif // !defined(_di_f_thread_mutexs_adjust_) || !defined(_di_f_thread_mutexs_decimate_by_)
+
+/**
+ * Private implementation for resizing.
+ *
+ * Intended to be shared to each of the different implementation variations.
+ *
+ * @param length
+ * The new size to use.
+ * @param mutexs
+ * The mutexs to resize.
+ *
+ * @return
+ * F_none on success.
+ *
+ * Errors (with error bit) from: f_memory_resize().
+ *
+ * @see f_memory_resize()
+ * @see f_thread_mutexs_decrease_by()
+ * @see f_thread_mutexs_increase()
+ * @see f_thread_mutexs_increase_by()
+ */
+#if !defined(_di_f_thread_mutexs_decrease_by_) || !defined(_di_f_thread_mutexs_increase_) || !defined(_di_f_thread_mutexs_increase_by_)
+ extern f_status_t private_f_thread_mutexs_resize(const f_array_length_t length, f_thread_mutexs_t *mutexs) f_gcc_attribute_visibility_internal;
+#endif // !defined(_di_f_thread_mutexs_decrease_by_) || !defined(_di_f_thread_mutexs_increase_) || !defined(_di_f_thread_mutexs_increase_by_)
+
+/**
+ * Private implementation for resizing.
+ *
+ * Intended to be shared to each of the different implementation variations.
+ *
+ * @param length
+ * The new size to use.
+ * @param sets
+ * The sets to adjust.
+ *
+ * @return
+ * F_none on success.
+ *
+ * Errors (with error bit) from: f_memory_adjust().
+ *
+ * @see f_memory_adjust()
+ * @see f_thread_sets_adjust()
+ * @see f_thread_sets_decimate_by()
+ */
+#if !defined(_di_f_thread_sets_adjust_) || !defined(_di_f_thread_sets_decimate_by_)
+ extern f_status_t private_f_thread_sets_adjust(const f_array_length_t length, f_thread_sets_t *sets) f_gcc_attribute_visibility_internal;
+#endif // !defined(_di_f_thread_sets_adjust_) || !defined(_di_f_thread_sets_decimate_by_)
+
+/**
+ * Private implementation for resizing.
+ *
+ * Intended to be shared to each of the different implementation variations.
+ *
+ * @param length
+ * The new size to use.
+ * @param sets
+ * The sets to resize.
+ *
+ * @return
+ * F_none on success.
+ *
+ * Errors (with error bit) from: f_memory_resize().
+ *
+ * @see f_memory_resize()
+ * @see f_thread_sets_decrease_by()
+ * @see f_thread_sets_increase()
+ * @see f_thread_sets_increase_by()
+ */
+#if !defined(_di_f_thread_sets_decrease_by_) || !defined(_di_f_thread_sets_increase_) || !defined(_di_f_thread_sets_increase_by_)
+ extern f_status_t private_f_thread_sets_resize(const f_array_length_t length, f_thread_sets_t *sets) f_gcc_attribute_visibility_internal;
+#endif // !defined(_di_f_thread_sets_decrease_by_) || !defined(_di_f_thread_sets_increase_) || !defined(_di_f_thread_sets_increase_by_)
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
+
+#endif // _PRIVATE_F_thread_h
// This does not clear the thread.attributes.__size array (may need to memset() against a sizeof(pthread_attr_t)).
#define f_macro_thread_attribute_t_clear(attribute) attribute.__align = 0
- #define f_macro_thread_attribute_t_delete(status, attribute) status = f_thread_attribute_delete(&attribute);
-
#define f_macro_thread_attribute_t_delete_simple(attribute) f_thread_attribute_delete(&attribute);
#endif // _di_f_thread_attribute_t_
#define f_thread_attributes_t_initialize { 0, 0, 0 }
- #define f_macro_thread_attributes_t_resize(status, attributes, length) f_macro_memory_structure_resize(status, attributes, f_thread_attribute_t, length)
- #define f_macro_thread_attributes_t_adjust(status, attributes, length) f_macro_memory_structure_adjust(status, attributes, f_thread_attribute_t, length)
+ #define f_macro_thread_attributes_t_clear(attributes) f_macro_memory_structure_clear(attributes)
- // @todo implement custom delete functions to call f_thread_attribute_delete() as appropriate.
- #define f_macro_thread_attributes_t_delete(status, attributes) f_macro_memory_structure_delete(status, attributes, f_thread_attribute_t)
- #define f_macro_thread_attributes_t_destroy(status, attributes) f_macro_memory_structure_destroy(status, attributes, f_thread_attribute_t)
+ #define f_macro_thread_attributes_t_resize(status, attributes, length) status = f_thread_attributes_resize(length, &attributes);
+ #define f_macro_thread_attributes_t_adjust(status, attributes, length) status = f_thread_attributes_adjust(length, &attributes);
- #define f_macro_thread_attributes_t_delete_simple(attributes) f_macro_memory_structure_delete_simple(attributes, f_thread_attribute_t)
- #define f_macro_thread_attributes_t_destroy_simple(attributes) f_macro_memory_structure_destroy_simple(attributes, f_thread_attribute_t)
+ #define f_macro_thread_attributes_t_delete_simple(attributes) f_thread_attributes_resize(0, &attributes);
+ #define f_macro_thread_attributes_t_destroy_simple(attributes) f_thread_attributes_adjust(0, &attributes);
- #define f_macro_thread_attributes_t_increase(status, attributes) f_macro_memory_structure_increase(status, attributes, f_thread_attribute_t)
- #define f_macro_thread_attributes_t_increase_by(status, attributes, amount) f_macro_memory_structure_increase_by(status, attributes, f_thread_attribute_t, amount)
- #define f_macro_thread_attributes_t_decrease_by(status, attributes, amount) f_macro_memory_structure_decrease_by(status, attributes, f_thread_attribute_t, amount)
- #define f_macro_thread_attributes_t_decimate_by(status, attributes, amount) f_macro_memory_structure_decimate_by(status, attributes, f_thread_attribute_t, amount)
+ #define f_macro_thread_attributes_t_increase(status, attributes) status = f_thread_attributes_increase(attributes);
+ #define f_macro_thread_attributes_t_increase_by(status, attributes, amount) status = f_thread_attributes_increase_by(amount, attributes);
+ #define f_macro_thread_attributes_t_decrease_by(status, attributes, amount) status = f_thread_attributes_decrease_by(amount, attributes);
+ #define f_macro_thread_attributes_t_decimate_by(status, attributes, amount) status = f_thread_attributes_decimate_by(amount, attributes);
#endif // _di_f_thread_attributes_t_
/**
#define f_macro_thread_conditions_t_resize(status, conditions, length) f_macro_memory_structure_resize(status, conditions, f_thread_condition_t, length)
#define f_macro_thread_conditions_t_adjust(status, conditions, length) f_macro_memory_structure_adjust(status, conditions, f_thread_condition_t, length)
- #define f_macro_thread_conditions_t_delete(status, conditions) f_macro_memory_structure_delete(status, conditions, f_thread_condition_t)
- #define f_macro_thread_conditions_t_destroy(status, conditions) f_macro_memory_structure_destroy(status, conditions, f_thread_condition_t)
-
#define f_macro_thread_conditions_t_delete_simple(conditions) f_macro_memory_structure_delete_simple(conditions, f_thread_condition_t)
#define f_macro_thread_conditions_t_destroy_simple(conditions) f_macro_memory_structure_destroy_simple(conditions, f_thread_condition_t)
#define f_macro_thread_ids_t_resize(status, ids, length) f_macro_memory_structure_resize(status, ids, f_thread_id_t, length)
#define f_macro_thread_ids_t_adjust(status, ids, length) f_macro_memory_structure_adjust(status, ids, f_thread_id_t, length)
- #define f_macro_thread_ids_t_delete(status, ids) f_macro_memory_structure_delete(status, ids, f_thread_id_t)
- #define f_macro_thread_ids_t_destroy(status, ids) f_macro_memory_structure_destroy(status, ids, f_thread_id_t)
-
#define f_macro_thread_ids_t_delete_simple(ids) f_macro_memory_structure_delete_simple(ids, f_thread_id_t)
#define f_macro_thread_ids_t_destroy_simple(ids) f_macro_memory_structure_destroy_simple(ids, f_thread_id_t)
#define f_macro_thread_keys_t_resize(status, keys, length) f_macro_memory_structure_resize(status, keys, f_thread_key_t, length)
#define f_macro_thread_keys_t_adjust(status, keys, length) f_macro_memory_structure_adjust(status, keys, f_thread_key_t, length)
- #define f_macro_thread_keys_t_delete(status, keys) f_macro_memory_structure_delete(status, keys, f_thread_key_t)
- #define f_macro_thread_keys_t_destroy(status, keys) f_macro_memory_structure_destroy(status, keys, f_thread_key_t)
-
#define f_macro_thread_keys_t_delete_simple(keys) f_macro_memory_structure_delete_simple(keys, f_thread_key_t)
#define f_macro_thread_keys_t_destroy_simple(keys) f_macro_memory_structure_destroy_simple(keys, f_thread_key_t)
#define f_macro_thread_locks_t_resize(status, locks, length) f_macro_memory_structure_resize(status, locks, f_thread_lock_t, length)
#define f_macro_thread_locks_t_adjust(status, locks, length) f_macro_memory_structure_adjust(status, locks, f_thread_lock_t, length)
- #define f_macro_thread_locks_t_delete(status, locks) f_macro_memory_structure_delete(status, locks, f_thread_lock_t)
- #define f_macro_thread_locks_t_destroy(status, locks) f_macro_memory_structure_destroy(status, locks, f_thread_lock_t)
-
#define f_macro_thread_locks_t_delete_simple(locks) f_macro_memory_structure_delete_simple(locks, f_thread_lock_t)
#define f_macro_thread_locks_t_destroy_simple(locks) f_macro_memory_structure_destroy_simple(locks, f_thread_lock_t)
#define f_macro_thread_mutex_t_clear(mutex) mutex = 0
- #define f_macro_thread_mutex_t_delete(status, mutex) status = f_thread_mutex_delete(&mutex);
-
#define f_macro_thread_mutex_t_delete_simple(mutex) f_thread_mutex_delete(&mutex);
#endif // _di_f_thread_mutex_t_
#define f_thread_mutexs_t_initialize { 0, 0, 0 }
- #define f_macro_thread_mutexs_t_resize(status, mutexs, length) f_macro_memory_structure_resize(status, mutexs, f_thread_mutex_t, length)
- #define f_macro_thread_mutexs_t_adjust(status, mutexs, length) f_macro_memory_structure_adjust(status, mutexs, f_thread_mutex_t, length)
+ #define f_macro_thread_mutexs_t_clear(mutexs) f_macro_memory_structure_clear(mutexs)
- // @todo implement custom delete functions to call f_thread_mutex_delete() as appropriate.
- #define f_macro_thread_mutexs_t_delete(status, mutexs) f_macro_memory_structure_delete(status, mutexs, f_thread_mutex_t)
- #define f_macro_thread_mutexs_t_destroy(status, mutexs) f_macro_memory_structure_destroy(status, mutexs, f_thread_mutex_t)
+ #define f_macro_thread_mutexs_t_resize(status, mutexs, length) status = f_thread_mutexs_resize(length, &mutexs);
+ #define f_macro_thread_mutexs_t_adjust(status, mutexs, length) status = f_thread_mutexs_adjust(length, &mutexs);
- #define f_macro_thread_mutexs_t_delete_simple(mutexs) f_macro_memory_structure_delete_simple(mutexs, f_thread_mutex_t)
- #define f_macro_thread_mutexs_t_destroy_simple(mutexs) f_macro_memory_structure_destroy_simple(mutexs, f_thread_mutex_t)
+ #define f_macro_thread_mutexs_t_delete_simple(mutexs) f_thread_mutexs_resize(0, &mutexs);
+ #define f_macro_thread_mutexs_t_destroy_simple(mutexs) f_thread_mutexs_adjust(0, &mutexs);
- #define f_macro_thread_mutexs_t_increase(status, mutexs) f_macro_memory_structure_increase(status, mutexs, f_thread_mutex_t)
- #define f_macro_thread_mutexs_t_increase_by(status, mutexs, amount) f_macro_memory_structure_increase_by(status, mutexs, f_thread_mutex_t, amount)
- #define f_macro_thread_mutexs_t_decrease_by(status, mutexs, amount) f_macro_memory_structure_decrease_by(status, mutexs, f_thread_mutex_t, amount)
- #define f_macro_thread_mutexs_t_decimate_by(status, mutexs, amount) f_macro_memory_structure_decimate_by(status, mutexs, f_thread_mutex_t, amount)
+ #define f_macro_thread_mutexs_t_increase(status, mutexs) status = f_thread_mutexs_increase(mutexs);
+ #define f_macro_thread_mutexs_t_increase_by(status, mutexs, amount) status = f_thread_mutexs_increase_by(amount, mutexs);
+ #define f_macro_thread_mutexs_t_decrease_by(status, mutexs, amount) status = f_thread_mutexs_decrease_by(amount, mutexs);
+ #define f_macro_thread_mutexs_t_decimate_by(status, mutexs, amount) status = f_thread_mutexs_decimate_by(amount, mutexs);
#endif // _di_f_thread_mutexs_t_
/**
#define f_macro_thread_mutex_attributes_t_resize(status, mutex_attributes, length) f_macro_memory_structure_resize(status, mutex_attributes, f_thread_mutex_attribute_t, length)
#define f_macro_thread_mutex_attributes_t_adjust(status, mutex_attributes, length) f_macro_memory_structure_adjust(status, mutex_attributes, f_thread_mutex_attribute_t, length)
- #define f_macro_thread_mutex_attributes_t_delete(status, mutex_attributes) f_macro_memory_structure_delete(status, mutex_attributes, f_thread_mutex_attribute_t)
- #define f_macro_thread_mutex_attributes_t_destroy(status, mutex_attributes) f_macro_memory_structure_destroy(status, mutex_attributes, f_thread_mutex_attribute_t)
-
#define f_macro_thread_mutex_attributes_t_delete_simple(mutex_attributes) f_macro_memory_structure_delete_simple(mutex_attributes, f_thread_mutex_attribute_t)
#define f_macro_thread_mutex_attributes_t_destroy_simple(mutex_attributes) f_macro_memory_structure_destroy_simple(mutex_attributes, f_thread_mutex_attribute_t)
#define f_macro_thread_onces_t_resize(status, onces, length) f_macro_memory_structure_resize(status, onces, f_thread_once_t, length)
#define f_macro_thread_onces_t_adjust(status, onces, length) f_macro_memory_structure_adjust(status, onces, f_thread_once_t, length)
- #define f_macro_thread_onces_t_delete(status, onces) f_macro_memory_structure_delete(status, onces, f_thread_once_t)
- #define f_macro_thread_onces_t_destroy(status, onces) f_macro_memory_structure_destroy(status, onces, f_thread_once_t)
-
#define f_macro_thread_onces_t_delete_simple(onces) f_macro_memory_structure_delete_simple(onces, f_thread_once_t)
#define f_macro_thread_onces_t_destroy_simple(onces) f_macro_memory_structure_destroy_simple(onces, f_thread_once_t)
/**
* A structure containing basic thread information.
*
- * attributes: The thread attributes (which is a union).
- * id: The thread identifier.
- * result: The result of the thread on exit.
+ * attribute: The thread attributes (which is a union).
+ * id: The thread identifier.
+ * result: The result of the thread on exit.
*/
#ifndef _di_f_thread_set_t_
typedef struct {
- f_thread_attribute_t attributes;
+ f_thread_attribute_t attribute;
f_thread_id_t id;
int result;
} f_thread_set_t;
#define f_thread_set_t_initialize { f_thread_attribute_t_initialize, f_thread_id_t_initialize, 0 }
#define f_macro_thread_set_t_clear(thread) \
- f_macro_thread_attribute_t_clear(thread.attributes) \
+ f_macro_thread_attribute_t_clear(thread.attribute) \
f_macro_thread_id_t_clear(thread.id)
- #define f_macro_thread_set_t_delete(status, set) f_macro_thread_attribute_t_delete(status, set.attribute)
-
#define f_macro_thread_set_t_delete_simple(set) f_macro_thread_attribute_t_delete_simple(set.attribute)
#endif // _di_f_thread_set_t_
#define f_thread_sets_t_initialize { 0, 0, 0 }
- #define f_macro_thread_sets_t_resize(status, sets, length) f_macro_memory_structure_resize(status, sets, f_thread_set_t, length)
- #define f_macro_thread_sets_t_adjust(status, sets, length) f_macro_memory_structure_adjust(status, sets, f_thread_set_t, length)
+ #define f_macro_thread_sets_t_clear(sets) f_macro_memory_structure_clear(sets)
- // @todo implement custom delete functions to call f_macro_thread_set_t_delete() as appropriate.
- #define f_macro_thread_sets_t_delete(status, sets) f_macro_memory_structure_delete(status, sets, f_thread_set_t)
- #define f_macro_thread_sets_t_destroy(status, sets) f_macro_memory_structure_destroy(status, sets, f_thread_set_t)
+ #define f_macro_thread_sets_t_resize(status, sets, length) status = f_thread_sets_resize(length, &sets);
+ #define f_macro_thread_sets_t_adjust(status, sets, length) status = f_thread_sets_adjust(length, &sets);
- #define f_macro_thread_sets_t_delete_simple(sets) f_macro_memory_structure_delete_simple(sets, f_thread_set_t)
- #define f_macro_thread_sets_t_destroy_simple(sets) f_macro_memory_structure_destroy_simple(sets, f_thread_set_t)
+ #define f_macro_thread_sets_t_delete_simple(sets) f_thread_sets_resize(0, &sets);
+ #define f_macro_thread_sets_t_destroy_simple(sets) f_thread_sets_adjust(0, &sets);
- #define f_macro_thread_sets_t_increase(status, sets) f_macro_memory_structure_increase(status, sets, f_thread_set_t)
- #define f_macro_thread_sets_t_increase_by(status, sets, amount) f_macro_memory_structure_increase_by(status, sets, f_thread_set_t, amount)
- #define f_macro_thread_sets_t_decrease_by(status, sets, amount) f_macro_memory_structure_decrease_by(status, sets, f_thread_set_t, amount)
- #define f_macro_thread_sets_t_decimate_by(status, sets, amount) f_macro_memory_structure_decimate_by(status, sets, f_thread_set_t, amount)
+ #define f_macro_thread_sets_t_increase(status, sets) status = f_thread_sets_increase(sets);
+ #define f_macro_thread_sets_t_increase_by(status, sets, amount) status = f_thread_sets_increase_by(amount, sets);
+ #define f_macro_thread_sets_t_decrease_by(status, sets, amount) status = f_thread_sets_decrease_by(amount, sets);
+ #define f_macro_thread_sets_t_decimate_by(status, sets, amount) status = f_thread_sets_decimate_by(amount, sets);
#endif // _di_f_thread_sets_t_
#ifdef __cplusplus
#include "thread.h"
+#include "private-thread.h"
#ifdef __cplusplus
extern "C" {
if (!attribute) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
- const int error = pthread_attr_destroy(attribute);
-
- if (error) {
- return F_status_set_error(F_failure);
- }
-
- attribute = 0;
-
- return F_none;
+ return private_f_thread_attribute_delete(attribute);
}
#endif // _di_f_thread_attribute_delete_
}
#endif // _di_f_thread_attribute_stack_set_
+#ifndef _di_f_thread_attributes_adjust_
+ f_status_t f_thread_attributes_adjust(const f_array_length_t length, f_thread_attributes_t *attributes) {
+ #ifndef _di_level_0_parameter_checking_
+ if (!attributes) return F_status_set_error(F_parameter);
+ #endif // _di_level_0_parameter_checking_
+
+ return private_f_thread_attributes_adjust(length, attributes);
+ }
+#endif // _di_f_thread_attributes_adjust_
+
+#ifndef _di_f_thread_attributes_decimate_by_
+ f_status_t f_thread_attributes_decimate_by(const f_array_length_t amount, f_thread_attributes_t *attributes) {
+ #ifndef _di_level_0_parameter_checking_
+ if (!amount) return F_status_set_error(F_parameter);
+ if (!attributes) return F_status_set_error(F_parameter);
+ #endif // _di_level_0_parameter_checking_
+
+ if (attributes->size - amount > 0) {
+ return private_f_thread_attributes_adjust(attributes->size - amount, attributes);
+ }
+
+ return private_f_thread_attributes_adjust(0, attributes);
+ }
+#endif // _di_f_thread_attributes_decimate_by_
+
+#ifndef _di_f_thread_attributes_decrease_by_
+ f_status_t f_thread_attributes_decrease_by(const f_array_length_t amount, f_thread_attributes_t *attributes) {
+ #ifndef _di_level_0_parameter_checking_
+ if (!amount) return F_status_set_error(F_parameter);
+ if (!attributes) return F_status_set_error(F_parameter);
+ #endif // _di_level_0_parameter_checking_
+
+ if (attributes->size - amount > 0) {
+ return private_f_thread_attributes_resize(attributes->size - amount, attributes);
+ }
+
+ return private_f_thread_attributes_resize(0, attributes);
+ }
+#endif // _di_f_thread_attributes_decrease_by_
+
+#ifndef _di_f_thread_attributes_increase_
+ f_status_t f_thread_attributes_increase(f_thread_attributes_t *attributes) {
+ #ifndef _di_level_0_parameter_checking_
+ if (!attributes) return F_status_set_error(F_parameter);
+ #endif // _di_level_0_parameter_checking_
+
+ if (attributes->used + 1 > attributes->size) {
+ f_array_length_t size = attributes->used + f_memory_default_allocation_step;
+
+ if (size > f_array_length_t_size) {
+ if (attributes->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_thread_attributes_resize(size, attributes);
+ }
+
+ return F_data_not;
+ }
+#endif // _di_f_thread_attributes_increase_
+
+#ifndef _di_f_thread_attributes_increase_by_
+ f_status_t f_thread_attributes_increase_by(const f_array_length_t amount, f_thread_attributes_t *attributes) {
+ #ifndef _di_level_0_parameter_checking_
+ if (!amount) return F_status_set_error(F_parameter);
+ if (!attributes) return F_status_set_error(F_parameter);
+ #endif // _di_level_0_parameter_checking_
+
+ if (attributes->used + amount > attributes->size) {
+ if (attributes->used + amount > f_array_length_t_size) {
+ return F_status_set_error(F_array_too_large);
+ }
+
+ return private_f_thread_attributes_resize(attributes->used + amount, attributes);
+ }
+
+ return F_data_not;
+ }
+#endif // _di_f_thread_attributes_increase_by_
+
+#ifndef _di_f_thread_attributes_resize_
+ f_status_t f_thread_attributes_resize(const f_array_length_t length, f_thread_attributes_t *attributes) {
+ #ifndef _di_level_0_parameter_checking_
+ if (!attributes) return F_status_set_error(F_parameter);
+ #endif // _di_level_0_parameter_checking_
+
+ return private_f_thread_attributes_resize(length, attributes);
+ }
+#endif // _di_f_thread_attributes_resize_
+
#ifndef _di_f_thread_caller_
f_thread_id_t f_thread_caller() {
return pthread_self();
if (!mutex) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
- const int error = pthread_mutex_destroy(mutex);
-
- if (error) {
- if (error == EBUSY) return F_status_set_error(F_busy);
- if (error == EINVAL) return F_status_set_error(F_parameter);
-
- return F_status_set_error(F_failure);
- }
-
- return F_none;
+ return private_f_thread_mutex_delete(mutex);
}
#endif // _di_f_thread_mutex_delete_
}
#endif // _di_f_thread_mutex_unlock_
+#ifndef _di_f_thread_mutexs_adjust_
+ f_status_t f_thread_mutexs_adjust(const f_array_length_t length, f_thread_mutexs_t *mutexs) {
+ #ifndef _di_level_0_parameter_checking_
+ if (!mutexs) return F_status_set_error(F_parameter);
+ #endif // _di_level_0_parameter_checking_
+
+ return private_f_thread_mutexs_adjust(length, mutexs);
+ }
+#endif // _di_f_thread_mutexs_adjust_
+
+#ifndef _di_f_thread_mutexs_decimate_by_
+ f_status_t f_thread_mutexs_decimate_by(const f_array_length_t amount, f_thread_mutexs_t *mutexs) {
+ #ifndef _di_level_0_parameter_checking_
+ if (!amount) return F_status_set_error(F_parameter);
+ if (!mutexs) return F_status_set_error(F_parameter);
+ #endif // _di_level_0_parameter_checking_
+
+ if (mutexs->size - amount > 0) {
+ return private_f_thread_mutexs_adjust(mutexs->size - amount, mutexs);
+ }
+
+ return private_f_thread_mutexs_adjust(0, mutexs);
+ }
+#endif // _di_f_thread_mutexs_decimate_by_
+
+#ifndef _di_f_thread_mutexs_decrease_by_
+ f_status_t f_thread_mutexs_decrease_by(const f_array_length_t amount, f_thread_mutexs_t *mutexs) {
+ #ifndef _di_level_0_parameter_checking_
+ if (!amount) return F_status_set_error(F_parameter);
+ if (!mutexs) return F_status_set_error(F_parameter);
+ #endif // _di_level_0_parameter_checking_
+
+ if (mutexs->size - amount > 0) {
+ return private_f_thread_mutexs_resize(mutexs->size - amount, mutexs);
+ }
+
+ return private_f_thread_mutexs_resize(0, mutexs);
+ }
+#endif // _di_f_thread_mutexs_decrease_by_
+
+#ifndef _di_f_thread_mutexs_increase_
+ f_status_t f_thread_mutexs_increase(f_thread_mutexs_t *mutexs) {
+ #ifndef _di_level_0_parameter_checking_
+ if (!mutexs) return F_status_set_error(F_parameter);
+ #endif // _di_level_0_parameter_checking_
+
+ if (mutexs->used + 1 > mutexs->size) {
+ f_array_length_t size = mutexs->used + f_memory_default_allocation_step;
+
+ if (size > f_array_length_t_size) {
+ if (mutexs->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_thread_mutexs_resize(size, mutexs);
+ }
+
+ return F_data_not;
+ }
+#endif // _di_f_thread_mutexs_increase_
+
+#ifndef _di_f_thread_mutexs_increase_by_
+ f_status_t f_thread_mutexs_increase_by(const f_array_length_t amount, f_thread_mutexs_t *mutexs) {
+ #ifndef _di_level_0_parameter_checking_
+ if (!amount) return F_status_set_error(F_parameter);
+ if (!mutexs) return F_status_set_error(F_parameter);
+ #endif // _di_level_0_parameter_checking_
+
+ if (mutexs->used + amount > mutexs->size) {
+ if (mutexs->used + amount > f_array_length_t_size) {
+ return F_status_set_error(F_array_too_large);
+ }
+
+ return private_f_thread_mutexs_resize(mutexs->used + amount, mutexs);
+ }
+
+ return F_data_not;
+ }
+#endif // _di_f_thread_mutexs_increase_by_
+
+#ifndef _di_f_thread_mutexs_resize_
+ f_status_t f_thread_mutexs_resize(const f_array_length_t length, f_thread_mutexs_t *mutexs) {
+ #ifndef _di_level_0_parameter_checking_
+ if (!mutexs) return F_status_set_error(F_parameter);
+ #endif // _di_level_0_parameter_checking_
+
+ return private_f_thread_mutexs_resize(length, mutexs);
+ }
+#endif // _di_f_thread_mutexs_resize_
+
#ifndef _di_f_thread_once_
f_status_t f_thread_once(void (*routine) (void), f_thread_once_t *once) {
#ifndef _di_level_0_parameter_checking_
}
#endif // _di_f_thread_once_
+#ifndef _di_f_thread_sets_adjust_
+ f_status_t f_thread_sets_adjust(const f_array_length_t length, f_thread_sets_t *sets) {
+ #ifndef _di_level_0_parameter_checking_
+ if (!sets) return F_status_set_error(F_parameter);
+ #endif // _di_level_0_parameter_checking_
+
+ return private_f_thread_sets_adjust(length, sets);
+ }
+#endif // _di_f_thread_sets_adjust_
+
+#ifndef _di_f_thread_sets_decimate_by_
+ f_status_t f_thread_sets_decimate_by(const f_array_length_t amount, f_thread_sets_t *sets) {
+ #ifndef _di_level_0_parameter_checking_
+ if (!amount) return F_status_set_error(F_parameter);
+ if (!sets) return F_status_set_error(F_parameter);
+ #endif // _di_level_0_parameter_checking_
+
+ if (sets->size - amount > 0) {
+ return private_f_thread_sets_adjust(sets->size - amount, sets);
+ }
+
+ return private_f_thread_sets_adjust(0, sets);
+ }
+#endif // _di_f_thread_sets_decimate_by_
+
+#ifndef _di_f_thread_sets_decrease_by_
+ f_status_t f_thread_sets_decrease_by(const f_array_length_t amount, f_thread_sets_t *sets) {
+ #ifndef _di_level_0_parameter_checking_
+ if (!amount) return F_status_set_error(F_parameter);
+ if (!sets) return F_status_set_error(F_parameter);
+ #endif // _di_level_0_parameter_checking_
+
+ if (sets->size - amount > 0) {
+ return private_f_thread_sets_resize(sets->size - amount, sets);
+ }
+
+ return private_f_thread_sets_resize(0, sets);
+ }
+#endif // _di_f_thread_sets_decrease_by_
+
+#ifndef _di_f_thread_sets_increase_
+ f_status_t f_thread_sets_increase(f_thread_sets_t *sets) {
+ #ifndef _di_level_0_parameter_checking_
+ if (!sets) return F_status_set_error(F_parameter);
+ #endif // _di_level_0_parameter_checking_
+
+ if (sets->used + 1 > sets->size) {
+ f_array_length_t size = sets->used + f_memory_default_allocation_step;
+
+ if (size > f_array_length_t_size) {
+ if (sets->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_thread_sets_resize(size, sets);
+ }
+
+ return F_data_not;
+ }
+#endif // _di_f_thread_sets_increase_
+
+#ifndef _di_f_thread_sets_increase_by_
+ f_status_t f_thread_sets_increase_by(const f_array_length_t amount, f_thread_sets_t *sets) {
+ #ifndef _di_level_0_parameter_checking_
+ if (!amount) return F_status_set_error(F_parameter);
+ if (!sets) return F_status_set_error(F_parameter);
+ #endif // _di_level_0_parameter_checking_
+
+ if (sets->used + amount > sets->size) {
+ if (sets->used + amount > f_array_length_t_size) {
+ return F_status_set_error(F_array_too_large);
+ }
+
+ return private_f_thread_sets_resize(sets->used + amount, sets);
+ }
+
+ return F_data_not;
+ }
+#endif // _di_f_thread_sets_increase_by_
+
+#ifndef _di_f_thread_sets_resize_
+ f_status_t f_thread_sets_resize(const f_array_length_t length, f_thread_sets_t *sets) {
+ #ifndef _di_level_0_parameter_checking_
+ if (!sets) return F_status_set_error(F_parameter);
+ #endif // _di_level_0_parameter_checking_
+
+ return private_f_thread_sets_resize(length, sets);
+ }
+#endif // _di_f_thread_sets_resize_
+
#ifndef _di_f_thread_signal_
f_status_t f_thread_signal(const f_thread_id_t id, const int signal) {
*
* @return
* F_none on success.
+ *
* F_parameter (with error bit) if a parameter is invalid.
* F_memory_not (with error bit) if out of memory.
* F_failure (with error bit) on any other error.
*
* @return
* F_none on success.
+ *
* F_parameter (with error bit) if a parameter is invalid.
* F_failure (with error bit) on any other error.
*
*
* @return
* F_none on success.
+ *
* F_memory_not (with error bit) if out of memory.
* F_parameter (with error bit) if a parameter is invalid.
* F_failure (with error bit) on any other error.
*
* @return
* F_none on success.
+ *
* F_parameter (with error bit) if a parameter is invalid.
* F_memory_not (with error bit) if out of memory.
* F_failure (with error bit) on any other error.
*
* @return
* F_none on success.
+ *
* F_parameter (with error bit) if a parameter is invalid.
* F_failure (with error bit) on any other error.
*
*
* @return
* F_none on success.
+ *
* F_memory_not (with error bit) if out of memory.
* F_parameter (with error bit) if a parameter is invalid.
* F_failure (with error bit) on any other error.
*
* On successfully delete, the pointer address is set to 0.
*
+ * The pthread_attr_destroy() function has no distinction like the *_destroy() and the *_delete() used by the FLL project.
+ * Therefore there is only this function for both deleting and destroying.
+ *
* @param attribute
* The thread attributes to delete.
*
* @return
* F_none on success.
+ *
* F_parameter (with error bit) if a parameter is invalid.
* F_failure (with error bit) on any other error.
*
*
* @return
* F_none on success.
+ *
* F_parameter (with error bit) if a parameter is invalid.
* F_failure (with error bit) on any other error.
*
*
* @return
* F_none on success.
+ *
* F_parameter (with error bit) if a parameter is invalid.
* F_failure (with error bit) on any other error.
*
*
* @return
* F_none on success.
+ *
* F_parameter (with error bit) if a parameter is invalid.
* F_failure (with error bit) on any other error.
*
*
* @return
* F_none on success.
+ *
* F_parameter (with error bit) if a parameter is invalid.
* F_failure (with error bit) on any other error.
*
*
* @return
* F_none on success.
+ *
* F_parameter (with error bit) if a parameter is invalid.
* F_failure (with error bit) on any other error.
*
*
* @return
* F_none on success.
+ *
* F_parameter (with error bit) if a parameter is invalid.
* F_failure (with error bit) on any other error.
*
*
* @return
* F_none on success.
+ *
* F_parameter (with error bit) if a parameter is invalid.
* F_failure (with error bit) on any other error.
*
*
* @return
* F_none on success.
+ *
* F_parameter (with error bit) if a parameter is invalid.
* F_failure (with error bit) on any other error.
*
*
* @return
* F_none on success.
+ *
* F_parameter (with error bit) if a parameter is invalid.
* F_failure (with error bit) on any other error.
*
*
* @return
* F_none on success.
+ *
* F_parameter (with error bit) if a parameter is invalid.
* F_failure (with error bit) on any other error.
*
*
* @return
* F_none on success.
+ *
* F_parameter (with error bit) if a parameter is invalid.
* F_failure (with error bit) on any other error.
*
*
* @return
* F_none on success.
+ *
* F_parameter (with error bit) if a parameter is invalid.
* F_supported_not (with error bit) if the scope is not supported by the current OS (such as Linux not supporting PTHREAD_SCOPE_PROCESS).
* F_failure (with error bit) on any other error.
*
* @return
* F_none on success.
+ *
* F_access_denied (with error bit) if the caller cannot both read and write to the stack address.
* F_parameter (with error bit) if a parameter is invalid.
* F_failure (with error bit) on any other error.
*
* @return
* F_none on success.
+ *
* F_access_denied (with error bit) if the caller cannot both read and write to the stack address.
* F_parameter (with error bit) if a parameter is invalid.
* F_failure (with error bit) on any other error.
#endif // _di_f_thread_attribute_stack_set_
/**
+ * Resize the string attributes array.
+ *
+ * @param length
+ * The new size to use.
+ * @param attributes
+ * The string attributes 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.
+ */
+#ifndef _di_f_thread_attributes_adjust_
+ extern f_status_t f_thread_attributes_adjust(const f_array_length_t length, f_thread_attributes_t *attributes);
+#endif // _di_f_thread_attributes_adjust_
+
+/**
+ * Resize the string attributes 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 attributes
+ * The string attributes 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.
+ */
+#ifndef _di_f_thread_attributes_decimate_by_
+ extern f_status_t f_thread_attributes_decimate_by(const f_array_length_t amount, f_thread_attributes_t *attributes);
+#endif // _di_f_thread_attributes_decimate_by_
+
+/**
+ * Resize the string attributes 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 attributes
+ * The string attributes 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.
+ */
+#ifndef _di_f_thread_attributes_decrease_by_
+ extern f_status_t f_thread_attributes_decrease_by(const f_array_length_t amount, f_thread_attributes_t *attributes);
+#endif // _di_f_thread_attributes_decrease_by_
+
+/**
+ * Increase the size of the string attributes 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 attributes
+ * The string attributes 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.
+ */
+#ifndef _di_f_thread_attributes_increase_
+ extern f_status_t f_thread_attributes_increase(f_thread_attributes_t *attributes);
+#endif // _di_f_thread_attributes_increase_
+
+/**
+ * Resize the string attributes 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 attributes
+ * The string attributes 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.
+ */
+#ifndef _di_f_thread_attributes_increase_by_
+ extern f_status_t f_thread_attributes_increase_by(const f_array_length_t amount, f_thread_attributes_t *attributes);
+#endif // _di_f_thread_attributes_increase_by_
+
+/**
+ * Resize the string attributes array.
+ *
+ * @param length
+ * The new size to use.
+ * @param attributes
+ * The string attributes 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.
+ */
+#ifndef _di_f_thread_attributes_resize_
+ extern f_status_t f_thread_attributes_resize(const f_array_length_t length, f_thread_attributes_t *attributes);
+#endif // _di_f_thread_attributes_resize_
+
+/**
* Get the ID of the calling thread.
*
* @return
*
* @return
* F_none on success.
+ *
* F_found_not (with error bit) if no thread by the given ID was found.
* F_failure (with error bit) on any other error.
*
*
* @return
* F_none on success.
+ *
* F_parameter (with error bit) if a parameter is invalid.
* F_failure (with error bit) on any other error.
*
*
* @return
* F_none on success.
+ *
* F_parameter (with error bit) if a parameter is invalid.
* F_failure (with error bit) on any other error.
*
*
* @return
* F_none on success.
+ *
* F_found_not (with error bit) if no thread by the given ID was found.
* F_supported_not (with error bit) if per-CPU clocks are not supported by the OS.
* F_failure (with error bit) on any other error.
*
* @return
* F_none on success.
+ *
* F_parameter (with error bit) if a parameter is invalid.
* F_failure (with error bit) on any other error.
*
*
* @return
* F_none on success.
+ *
* F_parameter (with error bit) if a parameter is invalid.
* F_failure (with error bit) on any other error.
*
*
* @return
* F_none on success.
+ *
* F_parameter (with error bit) if a parameter is invalid.
* F_failure (with error bit) on any other error.
*
* @return
* F_none on success.
* F_time on success, and wait timeout was reached before condition was triggered.
+ *
* F_parameter (with error bit) if a parameter is invalid.
* F_prohibited (with error bit) if not allowed to perform the operation (possibly because mutex is not owned by current thread).
* F_failure (with error bit) on any other error.
*
* @return
* F_none on success.
+ *
* F_parameter (with error bit) if a parameter is invalid.
* F_prohibited (with error bit) if not allowed to set the scheduling policy and parameters specified in attribute.
* F_resource_not (with error bit) if there are not enough resources to create another thread.
*
* @return
* F_none on success.
+ *
* F_deadlock (with error bit) if operation would cause a deadlock.ead.
* F_found_not (with error bit) if no thread by the given ID was found.
* F_parameter (with error bit) if a parameter is invalid.
*
* @return
* F_none on success.
+ *
* F_parameter (with error bit) if a parameter is invalid.
*
* @see pthread_exit()
*
* @return
* F_none on success.
+ *
* F_deadlock (with error bit) if operation would cause a deadlock.ead.
* F_found_not (with error bit) if no thread by the given ID was found.
* F_parameter (with error bit) if a parameter is invalid.
* @return
* F_none on success.
* F_busy on success, but thread could not be joined because it has not yet exited.
+ *
* F_deadlock (with error bit) if operation would cause a deadlock.ead.
* F_found_not (with error bit) if no thread by the given ID was found.
* F_parameter (with error bit) if a parameter is invalid.
* F_none on success.
* F_busy on success, but thread could not be joined because it has not yet exited.
* F_time on success, but thread could not be joined because it has not yet exited and the wait timeout was reached.
+ *
* F_deadlock (with error bit) if operation would cause a deadlock.
* F_found_not (with error bit) if no thread by the given ID was found.
* F_parameter (with error bit) if a parameter is invalid.
*
* @return
* F_none on success.
+ *
* F_memory_not (with error bit) if out of memory.
* F_parameter (with error bit) if a parameter is invalid.
* F_prohibited (with error bit) if not allowed to set the scheduling policy and parameters specified in attribute.
*
* @return
* F_none on success.
+ *
* F_parameter (with error bit) if a parameter is invalid.
*
* @see pthread_getspecific()
*
* @return
* F_none on success.
+ *
* F_parameter (with error bit) if a parameter is invalid.
*
* @see pthread_setspecific()
*
* @return
* F_none on success.
+ *
* F_deadlock (with error bit) if operation would cause a deadlock.
* F_parameter (with error bit) if a parameter is invalid.
* F_resource_not (with error bit) if max read/write locks is reached.
* @return
* F_none on success.
* F_busy on success, but the read/write lock is already locked.
+ *
* F_parameter (with error bit) if a parameter is invalid.
* F_resource_not (with error bit) if max read/write locks is reached.
*
*
* @return
* F_none on success.
+ *
* F_busy (with error bit) if the mutex is busy.
* F_memory_not (with error bit) if out of memory.
* F_parameter (with error bit) if a parameter is invalid.
#endif // _di_f_thread_mutex_create_
/**
- * Create a thread mutex.
+ * Delete a thread mutex.
+ *
+ * The pthread_mutex_destroy() function has no distinction like the *_destroy() and the *_delete() used by the FLL project.
+ * Therefore there is only this function for both deleting and destroying.
*
* @param mutex
* The mutex to delete.
*
* @return
* F_none on success.
+ *
* F_busy (with error bit) if the mutex is busy.
* F_parameter (with error bit) if a parameter is invalid.
* F_failure (with error bit) on any other error.
*
* @return
* F_none on success.
+ *
* F_deadlock (with error bit) if operation would cause a deadlock.
* F_parameter (with error bit) if a parameter is invalid.
* F_resource_not (with error bit) if max mutex locks is reached.
* @return
* F_none on success.
* F_busy on success, but the mutex is already locked.
+ *
* F_parameter (with error bit) if a parameter is invalid.
* F_resource_not (with error bit) if max mutex locks is reached.
*
*
* @return
* F_none on success.
+ *
* F_parameter (with error bit) if a parameter is invalid.
* F_prohibited (with error bit) if not allowed to perform the operation (possibly because mutex is not owned by current thread).
* F_resource_not (with error bit) if max mutex locks is reached.
#endif // _di_f_thread_mutex_unlock_
/**
+ * Resize the string mutexs array.
+ *
+ * @param length
+ * The new size to use.
+ * @param mutexs
+ * The string mutexs 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.
+ */
+#ifndef _di_f_thread_mutexs_adjust_
+ extern f_status_t f_thread_mutexs_adjust(const f_array_length_t length, f_thread_mutexs_t *mutexs);
+#endif // _di_f_thread_mutexs_adjust_
+
+/**
+ * Resize the string mutexs 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 mutexs
+ * The string mutexs 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.
+ */
+#ifndef _di_f_thread_mutexs_decimate_by_
+ extern f_status_t f_thread_mutexs_decimate_by(const f_array_length_t amount, f_thread_mutexs_t *mutexs);
+#endif // _di_f_thread_mutexs_decimate_by_
+
+/**
+ * Resize the string mutexs 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 mutexs
+ * The string mutexs 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.
+ */
+#ifndef _di_f_thread_mutexs_decrease_by_
+ extern f_status_t f_thread_mutexs_decrease_by(const f_array_length_t amount, f_thread_mutexs_t *mutexs);
+#endif // _di_f_thread_mutexs_decrease_by_
+
+/**
+ * Increase the size of the string mutexs 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 mutexs
+ * The string mutexs 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.
+ */
+#ifndef _di_f_thread_mutexs_increase_
+ extern f_status_t f_thread_mutexs_increase(f_thread_mutexs_t *mutexs);
+#endif // _di_f_thread_mutexs_increase_
+
+/**
+ * Resize the string mutexs 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 mutexs
+ * The string mutexs 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.
+ */
+#ifndef _di_f_thread_mutexs_increase_by_
+ extern f_status_t f_thread_mutexs_increase_by(const f_array_length_t amount, f_thread_mutexs_t *mutexs);
+#endif // _di_f_thread_mutexs_increase_by_
+
+/**
+ * Resize the string mutexs array.
+ *
+ * @param length
+ * The new size to use.
+ * @param mutexs
+ * The string mutexs 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.
+ */
+#ifndef _di_f_thread_mutexs_resize_
+ extern f_status_t f_thread_mutexs_resize(const f_array_length_t length, f_thread_mutexs_t *mutexs);
+#endif // _di_f_thread_mutexs_resize_
+
+/**
* Call the given routine only one time and never again.
*
* Subsequent calls will not call the given routine.
*
* @return
* F_none on success.
+ *
* F_parameter (with error bit) if a parameter is invalid.
*
* @see pthread_once()
#endif // _di_f_thread_once_
/**
+ * Resize the string sets array.
+ *
+ * @param length
+ * The new size to use.
+ * @param sets
+ * The string sets 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.
+ */
+#ifndef _di_f_thread_sets_adjust_
+ extern f_status_t f_thread_sets_adjust(const f_array_length_t length, f_thread_sets_t *sets);
+#endif // _di_f_thread_sets_adjust_
+
+/**
+ * Resize the string sets 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 sets
+ * The string sets 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.
+ */
+#ifndef _di_f_thread_sets_decimate_by_
+ extern f_status_t f_thread_sets_decimate_by(const f_array_length_t amount, f_thread_sets_t *sets);
+#endif // _di_f_thread_sets_decimate_by_
+
+/**
+ * Resize the string sets 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 sets
+ * The string sets 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.
+ */
+#ifndef _di_f_thread_sets_decrease_by_
+ extern f_status_t f_thread_sets_decrease_by(const f_array_length_t amount, f_thread_sets_t *sets);
+#endif // _di_f_thread_sets_decrease_by_
+
+/**
+ * Increase the size of the string sets 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 sets
+ * The string sets 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.
+ */
+#ifndef _di_f_thread_sets_increase_
+ extern f_status_t f_thread_sets_increase(f_thread_sets_t *sets);
+#endif // _di_f_thread_sets_increase_
+
+/**
+ * Resize the string sets 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 sets
+ * The string sets 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.
+ */
+#ifndef _di_f_thread_sets_increase_by_
+ extern f_status_t f_thread_sets_increase_by(const f_array_length_t amount, f_thread_sets_t *sets);
+#endif // _di_f_thread_sets_increase_by_
+
+/**
+ * Resize the string sets array.
+ *
+ * @param length
+ * The new size to use.
+ * @param sets
+ * The string sets 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.
+ */
+#ifndef _di_f_thread_sets_resize_
+ extern f_status_t f_thread_sets_resize(const f_array_length_t length, f_thread_sets_t *sets);
+#endif // _di_f_thread_sets_resize_
+
+/**
* Send a signal to the given thread.
*
* @param id
* @return
* F_none on success and signal is not 0.
* F_found on success, signal is 0, and the thread by the given ID does exist.
+ *
* F_found_not on success, signal is 0, and the thread by the given ID does not exist.
* F_found_not (with error bit) if no thread by the given ID was found (and signal is not 0).
* F_parameter (with error bit) if a parameter is invalid.
*
* @return
* F_none on success but no signal found.
+ *
* F_parameter (with error bit) if a parameter is invalid.
* F_failure (with error bit) for any other error.
*
*
* @return
* F_none on success but no signal found.
+ *
* F_found_not (with error bit) if no thread by the given ID was found.
* F_parameter (with error bit) if a parameter is invalid.
* F_resource_not (with error bit) if the max signals is reached.
build_language c
build_libraries -pthread -lc
build_libraries-individual -lf_memory
-build_sources_library thread.c
+build_sources_library thread.c private-thread.c
build_sources_program
build_sources_headers thread.h thread-common.h
build_sources_script
projects / fll / commitdiff