The socket.name is better as an f_string_static_t.
Fix the outdated and incorrect documentation comments for f_socket_t.
Add additional macro functions for initializing the f_socket_t.
build_sources_library rip.c rip/utf.c private-rip.c rip/private-utf.c
build_sources_library serialize.c private-serialize.c serialize/common.c
build_sources_library signal.c
-build_sources_library socket.c
+build_sources_library socket.c socket/socket.c socket/private-socket.c
build_sources_library status_string.c
build_sources_library string.c
build_sources_library private-string.c string/common.c
build_sources_headers rip.h rip/utf.h
build_sources_headers serialize.h serialize/common.h
build_sources_headers signal.h signal/common.h
-build_sources_headers socket.h socket/common.h
+build_sources_headers socket.h socket/socket.h socket/common.h
build_sources_headers status.h
build_sources_headers status_string.h
build_sources_headers string.h string/common.h
build_sources_headers string/static.h string/statics.h string/staticss.h
build_sources_headers string/triple.h string/triples.h string/tripless.h
build_sources_headers type.h type_file.h
-build_sources_headers type_array.h type_array/common.h type_array/cell.h type_array/file.h type_array/fll_id.h type_array/int8.h type_array/int16.h type_array/int32.h type_array/int64.h type_array/int128.h type_array/number_unsigned.h type_array/poll.h type_array/state.h type_array/status.h type_array/uint8.h type_array/uint16.h type_array/uint32.h type_array/uint64.h type_array/uint128.h
+build_sources_headers type_array.h type_array_file.h type_array/common.h type_array/cell.h type_array/file.h type_array/fll_id.h type_array/int8.h type_array/int16.h type_array/int32.h type_array/int64.h type_array/int128.h type_array/number_unsigned.h type_array/poll.h type_array/state.h type_array/status.h type_array/uint8.h type_array/uint16.h type_array/uint32.h type_array/uint64.h type_array/uint128.h
build_sources_headers utf.h utf/common.h utf/convert.h utf/dynamic.h utf/dynamics.h utf/dynamicss.h utf/is.h utf/is_character.h utf/map.h utf/maps.h utf/mapss.h utf/map_multi.h utf/map_multis.h utf/map_multiss.h utf/static.h utf/statics.h utf/staticss.h utf/string.h utf/triple.h utf/triples.h utf/tripless.h
build_sources_headers-thread thread.h thread/attribute.h thread/barrier.h thread/barrier_attribute.h thread/condition.h thread/condition_attribute.h thread/id.h thread/key.h thread/lock.h thread/lock_attribute.h thread/mutex.h thread/mutex_attribute.h thread/once.h thread/semaphore.h thread/set.h thread/spin.h
build_sources_library level_0/rip.c level_0/rip/utf.c level_0/private-rip.c level_0/rip/private-utf.c
build_sources_library level_0/serialize.c level_0/private-serialize.c level_0/serialize/common.c
build_sources_library level_0/signal.c
-build_sources_library level_0/socket.c
+build_sources_library level_0/socket.c level_0/socket/socket.c level_0/socket/private-socket.c
build_sources_library level_0/status_string.c
build_sources_library level_0/string.c
build_sources_library level_0/private-string.c level_0/string/common.c
build_sources_headers level_0/rip.h level_0/rip/utf.h
build_sources_headers level_0/serialize.h level_0/serialize/common.h
build_sources_headers level_0/signal.h level_0/signal/common.h
-build_sources_headers level_0/socket.h level_0/socket/common.h
+build_sources_headers level_0/socket.h level_0/socket/socket.h level_0/socket/common.h
build_sources_headers level_0/status.h
build_sources_headers level_0/status_string.h
build_sources_headers level_0/string.h level_0/string/common.h
build_sources_headers level_0/string/static.h level_0/string/statics.h level_0/string/staticss.h
build_sources_headers level_0/string/triple.h level_0/string/triples.h level_0/string/tripless.h
build_sources_headers level_0/type.h level_0/type_file.h
-build_sources_headers level_0/type_array.h level_0/type_array/common.h level_0/type_array/cell.h level_0/type_array/file.h level_0/type_array/fll_id.h level_0/type_array/int8.h level_0/type_array/int16.h level_0/type_array/int32.h level_0/type_array/int64.h level_0/type_array/int128.h level_0/type_array/number_unsigned.h level_0/type_array/poll.h level_0/type_array/state.h level_0/type_array/status.h level_0/type_array/uint8.h level_0/type_array/uint16.h level_0/type_array/uint32.h level_0/type_array/uint64.h level_0/type_array/uint128.h
+build_sources_headers level_0/type_array.h level_0/type_array_file.h level_0/type_array/common.h level_0/type_array/cell.h level_0/type_array/file.h level_0/type_array/fll_id.h level_0/type_array/int8.h level_0/type_array/int16.h level_0/type_array/int32.h level_0/type_array/int64.h level_0/type_array/int128.h level_0/type_array/number_unsigned.h level_0/type_array/poll.h level_0/type_array/state.h level_0/type_array/status.h level_0/type_array/uint8.h level_0/type_array/uint16.h level_0/type_array/uint32.h level_0/type_array/uint64.h level_0/type_array/uint128.h
build_sources_headers level_0/utf.h level_0/utf/common.h level_0/utf/convert.h level_0/utf/dynamic.h level_0/utf/dynamics.h level_0/utf/dynamicss.h level_0/utf/is.h level_0/utf/is_character.h level_0/utf/map.h level_0/utf/maps.h level_0/utf/mapss.h level_0/utf/map_multi.h level_0/utf/map_multis.h level_0/utf/map_multiss.h level_0/utf/static.h level_0/utf/statics.h level_0/utf/staticss.h level_0/utf/string.h level_0/utf/triple.h level_0/utf/triples.h level_0/utf/tripless.h
build_sources_headers level_1/control_group.h
address->sun_family = f_socket_domain_file_d;
- if (socket->name) {
- strncpy(address->sun_path, socket->name, sizeof(address->sun_path) - 1);
+ if (socket->name.used && socket->name.string) {
+ strncpy(address->sun_path, socket->name.string, socket->name.used);
+ address->sun_path[socket->name.used] = 0;
}
else {
address->sun_path[0] = 0;
// FLL-0 socket includes.
#include <fll/level_0/socket/common.h>
+#include <fll/level_0/socket/socket.h>
#ifdef __cplusplus
extern "C" {
/**
* Commonly used socket related properties, loosely based off of f_file_t.
*
- * address: Pointer to the socket address (stored as "struct sockaddr" but may represent other types such as "struct sockaddr_un" or "struct sockaddr_in").
- * domain: The socket domain (protocol family).
- * flag: Flags used for opening the file.
- * id: File descriptor, with a value of -1 represents a closed file.
- * name: The name of the socket, if a name is given (for UNIX sockets this represents the path) (Must be a NULL terminated string).
- * protocol: The socket protocol.
+ * id: File descriptor, with a value of -1 represents a closed file.
+ * domain: The socket domain (protocol family).
+ * protocol: The socket protocol.
+ * type: The socket type.
+ *
* size_read: The default number of 1-byte characters to read at a time and is often used for the read buffer size.
* size_write: The default number of 1-byte characters to read at a time and is often used for the write buffer size.
- * type: The socket type.
+ *
+ * length: The length of the socket.
+ * address: Pointer to the socket address (stored as "struct sockaddr" but may represent other types such as "struct sockaddr_un" or "struct sockaddr_in").
+ *
+ * name: The name of the socket, if a name is given (for UNIX sockets this represents the path) (Must be a NULL terminated string).
*/
#ifndef _di_f_socket_t_
typedef struct {
size_t size_write;
socklen_t length;
-
struct sockaddr *address;
- f_string_t name;
+ f_string_static_t name;
} f_socket_t;
- #define f_socket_t_initialize { -1, 0, 0, 0, F_socket_default_read_size_d, F_socket_default_write_size_d, 0, 0 }
+ #define f_socket_t_initialize { -1, 0, 0, 0, F_socket_default_read_size_d, F_socket_default_write_size_d, 0, 0, f_string_empty_s }
+
+ #define macro_f_socket_t_initialize_1(address, length) { \
+ -1, \
+ 0, \
+ 0, \
+ 0, \
+ F_socket_default_read_size_d, \
+ F_socket_default_write_size_d, \
+ address, \
+ length, \
+ f_string_empty_s \
+ }
+
+ #define macro_f_socket_t_initialize_2(address, length, name) { \
+ -1, \
+ 0, \
+ 0, \
+ 0, \
+ F_socket_default_read_size_d, \
+ F_socket_default_write_size_d, \
+ address, \
+ length, \
+ name \
+ }
- #define macro_f_socket_t_initialize_1(address) { -1, 0, 0, 0, F_socket_default_read_size_d, F_socket_default_write_size_d, address, 0 }
+ #define macro_f_socket_t_initialize_3(id, domain, protocol, type, address, length, name) { \
+ id, \
+ domain, \
+ protocol, \
+ type, \
+ F_socket_default_read_size_d, \
+ F_socket_default_write_size_d, \
+ address, \
+ length, \
+ name \
+ }
+
+ #define macro_f_socket_t_initialize_4(id, domain, protocol, type, size_read, size_write, address, length, name) { \
+ id, \
+ domain, \
+ protocol, \
+ type, \
+ size_read, \
+ size_write, \
+ address, \
+ length, \
+ name \
+ }
#define macro_f_socket_t_clear(file) \
file.id = -1; \
file.size_read = 0; \
file.size_write = 0; \
file.length = 0; \
- file.name = 0;
+ file.address = 0; \
+ macro_f_string_static_t_clear(file);
#define macro_f_socket_t_reset(file) \
file.id = -1; \
file.size_read = F_socket_default_read_size_d; \
file.size_write = F_socket_default_write_size_d; \
file.length = 0; \
- file.name = 0;
+ file.address = 0; \
+ macro_f_string_static_t_clear(file);
#endif // _di_f_socket_t_
+/**
+ * An array of f_socket_t.
+ *
+ * array: The array of f_socket_t.
+ * size: Total amount of allocated space.
+ * used: Total number of allocated spaces used.
+ */
+#ifndef _di_f_sockets_t_
+ typedef struct {
+ f_socket_t *array;
+
+ f_number_unsigned_t size;
+ f_number_unsigned_t used;
+ } f_sockets_t;
+
+ #define f_sockets_t_initialize { 0, 0, 0 }
+
+ #define macro_f_sockets_t_initialize_1(array, size, used) { array, size, used }
+ #define macro_f_sockets_t_initialize_2(array, length) { array, length, length }
+#endif // _di_f_sockets_t_
+
+/**
+ * This holds an array of f_sockets_t.
+ *
+ * array: The array of f_socket_t arrays.
+ * size: Total amount of allocated space.
+ * used: Total number of allocated spaces used.
+ */
+#ifndef _di_f_socketss_t_
+ typedef struct {
+ f_sockets_t *array;
+
+ f_number_unsigned_t size;
+ f_number_unsigned_t used;
+ } f_socketss_t;
+
+ #define f_socketss_t_initialize { 0, 0, 0 }
+
+ #define macro_f_socketss_t_initialize_1(array, size, used) { array, size, used }
+ #define macro_f_socketss_t_initialize_2(array, length) { array, length, length }
+#endif // _di_f_socketss_t_
+
#ifdef __cplusplus
} // extern "C"
#endif
--- /dev/null
+#include "../socket.h"
+#include "private-socket.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#if !defined(_di_f_sockets_adjust_) || !defined(_di_f_sockets_decimate_by_)
+ f_status_t private_f_sockets_adjust(const f_number_unsigned_t length, f_sockets_t * const sockets) {
+
+ const f_status_t status = f_memory_adjust(sockets->size, length, sizeof(f_socket_t), (void **) & sockets->array);
+ if (F_status_is_error(status)) return status;
+
+ sockets->size = length;
+
+ if (sockets->used > sockets->size) {
+ sockets->used = length;
+ }
+
+ return F_none;
+ }
+#endif // !defined(_di_f_sockets_adjust_) || !defined(_di_f_sockets_decimate_by_)
+
+#if !defined(_di_f_sockets_append_) || !defined(_di_f_socketss_append_)
+ extern f_status_t private_f_sockets_append(const f_socket_t source, f_sockets_t * const destination) {
+
+ if (destination->used + 1 > destination->size) {
+ const f_status_t status = private_f_sockets_resize(destination->used + F_memory_default_allocation_small_d, destination);
+ if (F_status_is_error(status)) return status;
+ }
+
+ destination->array[destination->used++] = source;
+
+ return F_none;
+ }
+#endif // !defined(_di_f_sockets_append_) || !defined(_di_f_socketss_append_)
+
+#if !defined(_di_f_sockets_append_) || !defined(_di_f_sockets_append_all_) || !defined(_di_f_socketss_append_all_)
+ extern f_status_t private_f_sockets_append_all(const f_sockets_t source, f_sockets_t * const destination) {
+
+
+
+ if (destination->used + source.used > destination->size) {
+ const f_status_t status = private_f_sockets_resize(destination->used + source.used, destination);
+ if (F_status_is_error(status)) return status;
+ }
+
+ for (f_number_unsigned_t i = 0; i < source.used; ++i) {
+ destination->array[destination->used++] = source.array[i];
+ } // for
+
+ return F_none;
+ }
+#endif // !defined(_di_f_sockets_append_) || !defined(_di_f_sockets_append_all_) || !defined(_di_f_socketss_append_all_)
+
+#if !defined(_di_f_sockets_resize_) || !defined(_di_f_sockets_append_) || !defined(_di_f_sockets_decrease_by_) || !defined(_di_f_socketss_append_)
+ f_status_t private_f_sockets_resize(const f_number_unsigned_t length, f_sockets_t * const sockets) {
+
+ const f_status_t status = f_memory_resize(sockets->size, length, sizeof(f_socket_t), (void **) & sockets->array);
+ if (F_status_is_error(status)) return status;
+
+ sockets->size = length;
+
+ if (sockets->used > sockets->size) {
+ sockets->used = length;
+ }
+
+ return F_none;
+ }
+#endif // !defined(_di_f_sockets_resize_) || !defined(_di_f_sockets_append_) || !defined(_di_f_sockets_decrease_by_) || !defined(_di_f_socketss_append_)
+
+#if !defined(_di_f_socketss_adjust_) || !defined(_di_f_socketss_decimate_by_)
+ f_status_t private_f_socketss_adjust(const f_number_unsigned_t length, f_socketss_t * const socketss) {
+
+ f_status_t status = F_none;
+
+ for (f_number_unsigned_t i = length; i < socketss->size; ++i) {
+
+ status = f_memory_destroy(socketss->array[i].size, sizeof(f_socket_t), (void **) & socketss->array[i].array);
+ if (F_status_is_error(status)) return status;
+
+ socketss->array[i].size = 0;
+ socketss->array[i].used = 0;
+ } // for
+
+ status = f_memory_adjust(socketss->size, length, sizeof(f_sockets_t), (void **) & socketss->array);
+ if (F_status_is_error(status)) return status;
+
+ socketss->size = length;
+
+ if (socketss->used > socketss->size) {
+ socketss->used = length;
+ }
+
+ return F_none;
+ }
+#endif // !defined(_di_f_socketss_adjust_) || !defined(_di_f_socketss_decimate_by_)
+
+#if !defined(_di_f_socketss_decrease_by_) || !defined(_di_f_socketss_increase_) || !defined(_di_f_socketss_increase_by_) || !defined(_di_f_socketss_resize_)
+ f_status_t private_f_socketss_resize(const f_number_unsigned_t length, f_socketss_t * const socketss) {
+
+ f_status_t status = F_none;
+
+ for (f_number_unsigned_t i = length; i < socketss->size; ++i) {
+
+ status = f_memory_delete(socketss->array[i].size, sizeof(f_socket_t), (void **) & socketss->array[i].array);
+ if (F_status_is_error(status)) return status;
+
+ socketss->array[i].size = 0;
+ socketss->array[i].used = 0;
+ } // for
+
+ status = f_memory_resize(socketss->size, length, sizeof(f_sockets_t), (void **) & socketss->array);
+ if (F_status_is_error(status)) return status;
+
+ socketss->size = length;
+
+ if (socketss->used > socketss->size) {
+ socketss->used = length;
+ }
+
+ return F_none;
+ }
+#endif // !defined(_di_f_socketss_decrease_by_) || !defined(_di_f_socketss_increase_) || !defined(_di_f_socketss_increase_by_) || !defined(_di_f_socketss_resize_)
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
--- /dev/null
+/**
+ * FLL - Level 0
+ *
+ * Project: Socket
+ * API Version: 0.7
+ * Licenses: lgpl-2.1-or-later
+ *
+ * These are provided for internal reduction in redundant code.
+ * These should not be exposed/used outside of this project.
+ */
+#ifndef _PRIVATE_F_socket_socket_h
+#define _PRIVATE_F_socket_socket_h
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * Private implementation for resizing the sockets array.
+ *
+ * Intended to be shared to each of the different implementation variations.
+ *
+ * @param length
+ * The length to adjust to.
+ * @param sockets
+ * The sockets 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_sockets_adjust()
+ * @see f_sockets_decimate_by()
+ */
+#if !defined(_di_f_sockets_adjust_) || !defined(_di_f_sockets_decimate_by_)
+ extern f_status_t private_f_sockets_adjust(const f_number_unsigned_t length, f_sockets_t * const sockets) F_attribute_visibility_internal_d;
+#endif // !defined(_di_f_sockets_adjust_) || !defined(_di_f_sockets_decimate_by_)
+
+/**
+ * Private implementation for appending the socket array.
+ *
+ * Intended to be shared to each of the different implementation variations.
+ *
+ * @param source
+ * The source socket 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_memory_resize()
+ * @see f_sockets_append()
+ * @see f_socketss_append()
+ */
+#if !defined(_di_f_sockets_append_) || !defined(_di_f_socketss_append_)
+ extern f_status_t private_f_sockets_append(const f_socket_t source, f_sockets_t * const destination) F_attribute_visibility_internal_d;
+#endif // !defined(_di_f_sockets_append_) || !defined(_di_f_socketss_append_)
+
+/**
+ * Private implementation for appending the socket array.
+ *
+ * Intended to be shared to each of the different implementation variations.
+ *
+ * @param source
+ * The source sockets 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_memory_resize()
+ * @see f_sockets_append_all()
+ * @see f_socketss_append()
+ * @see f_socketss_append_all()
+ */
+#if !defined(_di_f_sockets_append_) || !defined(_di_f_sockets_append_all_) || !defined(_di_f_socketss_append_all_)
+ extern f_status_t private_f_sockets_append_all(const f_sockets_t source, f_sockets_t * const destination) F_attribute_visibility_internal_d;
+#endif // !defined(_di_f_sockets_append_) || !defined(_di_f_sockets_append_all_) || !defined(_di_f_socketss_append_all_)
+
+/**
+ * Private implementation for resizing the sockets array.
+ *
+ * Intended to be shared to each of the different implementation variations.
+ *
+ * @param length
+ * The length to adjust to.
+ * @param sockets
+ * The sockets 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_sockets_resize()
+ * @see f_sockets_append()
+ * @see f_sockets_decrease_by()
+ * @see f_socketss_append()
+ */
+#if !defined(_di_f_sockets_resize_) || !defined(_di_f_sockets_append_) || !defined(_di_f_sockets_decrease_by_) || !defined(_di_f_socketss_append_)
+ extern f_status_t private_f_sockets_resize(const f_number_unsigned_t length, f_sockets_t * const sockets) F_attribute_visibility_internal_d;
+#endif // !defined(_di_f_sockets_resize_) || !defined(_di_f_sockets_append_) || !defined(_di_f_sockets_decrease_by_) || !defined(_di_f_socketss_append_)
+
+/**
+ * Private implementation for resizing the socketss array.
+ *
+ * Intended to be shared to each of the different implementation variations.
+ *
+ * @param length
+ * The length to adjust to.
+ * @param socketss
+ * The socketss array to adjust.
+ *
+ * @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 new length is larger than max array length.
+ * 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_socketss_adjust()
+ * @see f_socketss_decimate_by()
+ */
+#if !defined(_di_f_socketss_adjust_) || !defined(_di_f_socketss_decimate_by_)
+ extern f_status_t private_f_socketss_adjust(const f_number_unsigned_t length, f_socketss_t * const socketss) F_attribute_visibility_internal_d;
+#endif // !defined(_di_f_socketss_adjust_) || !defined(_di_f_socketss_decimate_by_)
+
+/**
+ * Private implementation for resizing the socketss array.
+ *
+ * Intended to be shared to each of the different implementation variations.
+ *
+ * @param length
+ * The length to resize to.
+ * @param socketss
+ * The socketss 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 new length is larger than max array length.
+ * 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_socketss_decrease_by()
+ * @see f_socketss_increase()
+ * @see f_socketss_increase_by()
+ * @see f_socketss_resize()
+ */
+#if !defined(_di_f_socketss_decrease_by_) || !defined(_di_f_socketss_increase_) || !defined(_di_f_socketss_increase_by_) || !defined(_di_f_socketss_resize_)
+ extern f_status_t private_f_socketss_resize(const f_number_unsigned_t length, f_socketss_t * const socketss) F_attribute_visibility_internal_d;
+#endif // !defined(_di_f_socketss_decrease_by_) || !defined(_di_f_socketss_increase_) || !defined(_di_f_socketss_increase_by_) || !defined(_di_f_socketss_resize_)
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
+
+#endif // _PRIVATE_F_socket_socket_h
--- /dev/null
+#include "../socket.h"
+#include "socket.h"
+#include "private-socket.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifndef _di_f_sockets_adjust_
+ f_status_t f_sockets_adjust(const f_number_unsigned_t length, f_sockets_t * const sockets) {
+ #ifndef _di_level_0_parameter_checking_
+ if (!sockets) return F_status_set_error(F_parameter);
+ #endif // _di_level_0_parameter_checking_
+
+ return private_f_sockets_adjust(length, sockets);
+ }
+#endif // _di_f_sockets_adjust_
+
+#ifndef _di_f_sockets_append_
+ f_status_t f_sockets_append(const f_socket_t source, f_sockets_t * const 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_sockets_append(source, destination);
+ }
+#endif // _di_f_sockets_append_
+
+#ifndef _di_f_sockets_append_all_
+ f_status_t f_sockets_append_all(const f_sockets_t source, f_sockets_t * const destination) {
+ #ifndef _di_level_0_parameter_checking_
+ if (!destination) return F_status_set_error(F_parameter);
+ #endif // _di_level_0_parameter_checking_
+
+ if (!source.used) return F_data_not;
+
+ return private_f_sockets_append_all(source, destination);
+ }
+#endif // _di_f_sockets_append_all_
+
+#ifndef _di_f_sockets_decimate_by_
+ f_status_t f_sockets_decimate_by(const f_number_unsigned_t amount, f_sockets_t * const sockets) {
+ #ifndef _di_level_0_parameter_checking_
+ if (!sockets) return F_status_set_error(F_parameter);
+ #endif // _di_level_0_parameter_checking_
+
+ if (!amount) return F_data_not;
+
+ if (sockets->size - amount > 0) {
+ return private_f_sockets_adjust(sockets->size - amount, sockets);
+ }
+
+ return private_f_sockets_adjust(0, sockets);
+ }
+#endif // _di_f_sockets_decimate_by_
+
+#ifndef _di_f_sockets_decrease_by_
+ f_status_t f_sockets_decrease_by(const f_number_unsigned_t amount, f_sockets_t * const sockets) {
+ #ifndef _di_level_0_parameter_checking_
+ if (!sockets) return F_status_set_error(F_parameter);
+ #endif // _di_level_0_parameter_checking_
+
+ if (!amount) return F_data_not;
+
+ if (sockets->size - amount > 0) {
+ return private_f_sockets_resize(sockets->size - amount, sockets);
+ }
+
+ return private_f_sockets_resize(0, sockets);
+ }
+#endif // _di_f_sockets_decrease_by_
+
+#ifndef _di_f_sockets_increase_
+ f_status_t f_sockets_increase(const f_number_unsigned_t step, f_sockets_t * const sockets) {
+ #ifndef _di_level_0_parameter_checking_
+ if (!sockets) return F_status_set_error(F_parameter);
+ #endif // _di_level_0_parameter_checking_
+
+ if (step && sockets->used + 1 > sockets->size) {
+ f_number_unsigned_t size = sockets->used + step;
+
+ if (size > F_number_t_size_unsigned_d) {
+ if (sockets->used + 1 > F_number_t_size_unsigned_d) {
+ return F_status_set_error(F_array_too_large);
+ }
+
+ size = F_number_t_size_unsigned_d;
+ }
+
+ return private_f_sockets_resize(size, sockets);
+ }
+
+ return F_data_not;
+ }
+#endif // _di_f_sockets_increase_
+
+#ifndef _di_f_sockets_increase_by_
+ f_status_t f_sockets_increase_by(const f_number_unsigned_t amount, f_sockets_t * const sockets) {
+ #ifndef _di_level_0_parameter_checking_
+ if (!sockets) return F_status_set_error(F_parameter);
+ #endif // _di_level_0_parameter_checking_
+
+ if (!amount) return F_data_not;
+
+ if (sockets->used + amount > sockets->size) {
+ if (sockets->used + amount > F_number_t_size_unsigned_d) {
+ return F_status_set_error(F_array_too_large);
+ }
+
+ return private_f_sockets_resize(sockets->used + amount, sockets);
+ }
+
+ return F_data_not;
+ }
+#endif // _di_f_sockets_increase_by_
+
+#ifndef _di_f_sockets_resize_
+ f_status_t f_sockets_resize(const f_number_unsigned_t length, f_sockets_t * const sockets) {
+ #ifndef _di_level_0_parameter_checking_
+ if (!sockets) return F_status_set_error(F_parameter);
+ #endif // _di_level_0_parameter_checking_
+
+ return private_f_sockets_resize(length, sockets);
+ }
+#endif // _di_f_sockets_resize_
+
+#ifndef _di_f_socketss_adjust_
+ f_status_t f_socketss_adjust(const f_number_unsigned_t length, f_socketss_t * const socketss) {
+ #ifndef _di_level_0_parameter_checking_
+ if (!socketss) return F_status_set_error(F_parameter);
+ #endif // _di_level_0_parameter_checking_
+
+ return private_f_socketss_adjust(length, socketss);
+ }
+#endif // _di_f_socketss_adjust_
+
+#ifndef _di_f_socketss_append_
+ f_status_t f_socketss_append(const f_sockets_t source, f_socketss_t * const destination) {
+ #ifndef _di_level_0_parameter_checking_
+ if (!destination) return F_status_set_error(F_parameter);
+ #endif // _di_level_0_parameter_checking_
+
+ if (!source.used) return F_data_not;
+
+ f_status_t status = F_none;
+
+ if (destination->used + 1 > destination->size) {
+ status = private_f_socketss_resize(destination->used + F_memory_default_allocation_small_d, destination);
+ if (F_status_is_error(status)) return status;
+ }
+
+ status = private_f_sockets_append_all(source, &destination->array[destination->used]);
+ if (F_status_is_error(status)) return status;
+
+ ++destination->used;
+
+ return F_none;
+ }
+#endif // _di_f_socketss_append_
+
+#ifndef _di_f_socketss_append_all_
+ f_status_t f_socketss_append_all(const f_socketss_t source, f_socketss_t * const destination) {
+ #ifndef _di_level_0_parameter_checking_
+ if (!destination) return F_status_set_error(F_parameter);
+ #endif // _di_level_0_parameter_checking_
+
+ if (!source.used) return F_data_not;
+
+ f_status_t status = F_none;
+
+ if (destination->used + source.used > destination->size) {
+ status = private_f_socketss_resize(destination->used + source.used, destination);
+ if (F_status_is_error(status)) return status;
+ }
+
+ for (f_number_unsigned_t i = 0; i < source.used; ++i, ++destination->used) {
+
+ destination->array[destination->used].used = 0;
+
+ if (source.array[i].used) {
+ status = private_f_sockets_append_all(source.array[i], &destination->array[destination->used]);
+ if (F_status_is_error(status)) return status;
+ }
+ } // for
+
+ return F_none;
+ }
+#endif // _di_f_socketss_append_all_
+
+#ifndef _di_f_socketss_decimate_by_
+ f_status_t f_socketss_decimate_by(const f_number_unsigned_t amount, f_socketss_t * const socketss) {
+ #ifndef _di_level_0_parameter_checking_
+ if (!socketss) return F_status_set_error(F_parameter);
+ #endif // _di_level_0_parameter_checking_
+
+ if (!amount) return F_data_not;
+
+ if (socketss->size - amount > 0) {
+ return private_f_socketss_adjust(socketss->size - amount, socketss);
+ }
+
+ return private_f_socketss_adjust(0, socketss);
+ }
+#endif // _di_f_socketss_decimate_by_
+
+#ifndef _di_f_socketss_decrease_by_
+ f_status_t f_socketss_decrease_by(const f_number_unsigned_t amount, f_socketss_t * const socketss) {
+ #ifndef _di_level_0_parameter_checking_
+ if (!socketss) return F_status_set_error(F_parameter);
+ #endif // _di_level_0_parameter_checking_
+
+ if (!amount) return F_data_not;
+
+ if (socketss->size - amount > 0) {
+ return private_f_socketss_resize(socketss->size - amount, socketss);
+ }
+
+ return private_f_socketss_resize(0, socketss);
+ }
+#endif // _di_f_socketss_decrease_by_
+
+#ifndef _di_f_socketss_increase_
+ f_status_t f_socketss_increase(const f_number_unsigned_t step, f_socketss_t * const socketss) {
+ #ifndef _di_level_0_parameter_checking_
+ if (!socketss) return F_status_set_error(F_parameter);
+ #endif // _di_level_0_parameter_checking_
+
+ if (step && socketss->used + 1 > socketss->size) {
+ f_number_unsigned_t size = socketss->used + step;
+
+ if (size > F_number_t_size_unsigned_d) {
+ if (socketss->used + 1 > F_number_t_size_unsigned_d) {
+ return F_status_set_error(F_array_too_large);
+ }
+
+ size = F_number_t_size_unsigned_d;
+ }
+
+ return private_f_socketss_resize(size, socketss);
+ }
+
+ return F_data_not;
+ }
+#endif // _di_f_socketss_increase_
+
+#ifndef _di_f_socketss_increase_by_
+ f_status_t f_socketss_increase_by(const f_number_unsigned_t amount, f_socketss_t * const socketss) {
+ #ifndef _di_level_0_parameter_checking_
+ if (!socketss) return F_status_set_error(F_parameter);
+ #endif // _di_level_0_parameter_checking_
+
+ if (!amount) return F_data_not;
+
+ if (socketss->used + amount > socketss->size) {
+ if (socketss->used + amount > F_number_t_size_unsigned_d) {
+ return F_status_set_error(F_array_too_large);
+ }
+
+ return private_f_socketss_resize(socketss->used + amount, socketss);
+ }
+
+ return F_data_not;
+ }
+#endif // _di_f_socketss_increase_by_
+
+#ifndef _di_f_socketss_resize_
+ f_status_t f_socketss_resize(const f_number_unsigned_t length, f_socketss_t * const socketss) {
+ #ifndef _di_level_0_parameter_checking_
+ if (!socketss) return F_status_set_error(F_parameter);
+ #endif // _di_level_0_parameter_checking_
+
+ return private_f_socketss_resize(length, socketss);
+ }
+#endif // _di_f_socketss_resize_
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
--- /dev/null
+/**
+ * FLL - Level 0
+ *
+ * Project: Socket
+ * API Version: 0.7
+ * Licenses: lgpl-2.1-or-later
+ *
+ * Defines socket type related functionality.
+ *
+ * This is auto-included by socket.h and should not need to be explicitly included.
+ */
+#ifndef _F_socket_socket_h
+#define _F_socket_socket_h
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * Resize the string sockets array.
+ *
+ * @param length
+ * The new size to use.
+ * @param sockets
+ * The string sockets 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_sockets_adjust_
+ extern f_status_t f_sockets_adjust(const f_number_unsigned_t length, f_sockets_t * const sockets);
+#endif // _di_f_sockets_adjust_
+
+/**
+ * Append the single source socket onto the destination.
+ *
+ * @param source
+ * The source socket to append.
+ * @param destination
+ * The destination sockets the source is appended onto.
+ *
+ * @return
+ * F_none on success.
+ * F_data_not on success, but there is nothing to append (size == 0).
+ *
+ * F_parameter (with error bit) if a parameter is invalid.
+ *
+ * Errors (with error bit) from: f_memory_resize().
+ */
+#ifndef _di_f_sockets_append_
+ extern f_status_t f_sockets_append(const f_socket_t source, f_sockets_t * const destination);
+#endif // _di_f_sockets_append_
+
+/**
+ * Append the source sockets onto the destination.
+ *
+ * @param source
+ * The source sockets to append.
+ * @param destination
+ * The destination sockets the source is appended onto.
+ *
+ * @return
+ * F_none on success.
+ * F_data_not on success, but there is nothing to append (size == 0).
+ *
+ * F_parameter (with error bit) if a parameter is invalid.
+ *
+ * Errors (with error bit) from: f_memory_resize().
+ */
+#ifndef _di_f_sockets_append_all_
+ extern f_status_t f_sockets_append_all(const f_sockets_t source, f_sockets_t * const destination);
+#endif // _di_f_sockets_append_all_
+
+/**
+ * Resize the string sockets 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 sockets
+ * The string sockets array to resize.
+ *
+ * @return
+ * F_none on success.
+ * F_data_not if amount is 0.
+ *
+ * F_parameter (with error bit) if a parameter is invalid.
+ *
+ * Errors (with error bit) from: f_memory_adjust().
+ */
+#ifndef _di_f_sockets_decimate_by_
+ extern f_status_t f_sockets_decimate_by(const f_number_unsigned_t amount, f_sockets_t * const sockets);
+#endif // _di_f_sockets_decimate_by_
+
+/**
+ * Resize the string sockets 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 sockets
+ * The string sockets array to resize.
+ *
+ * @return
+ * F_none on success.
+ * F_data_not if amount is 0.
+ *
+ * F_parameter (with error bit) if a parameter is invalid.
+ *
+ * Errors (with error bit) from: f_memory_resize().
+ */
+#ifndef _di_f_sockets_decrease_by_
+ extern f_status_t f_sockets_decrease_by(const f_number_unsigned_t amount, f_sockets_t * const sockets);
+#endif // _di_f_sockets_decrease_by_
+
+/**
+ * Increase the size of the string sockets array, but only if necesary.
+ *
+ * If the given length is too large for the buffer, then attempt to set max buffer size (F_number_t_size_unsigned_d).
+ * If already set to the maximum buffer size, then the resize will fail.
+ *
+ * @param step
+ * The allocation step to use.
+ * Must be greater than 0.
+ * @param sockets
+ * The string sockets 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_parameter (with error bit) if a parameter is invalid.
+ *
+ * Errors (with error bit) from: f_memory_resize().
+ */
+#ifndef _di_f_sockets_increase_
+ extern f_status_t f_sockets_increase(const f_number_unsigned_t step, f_sockets_t * const sockets);
+#endif // _di_f_sockets_increase_
+
+/**
+ * Resize the string sockets array to a larger size.
+ *
+ * This will resize making the array larger based on the given length.
+ * If the given length is too large for the buffer, then attempt to set max buffer size (F_number_t_size_unsigned_d).
+ * 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 sockets
+ * The string sockets 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_array_too_large (with error bit) if the new array length is too large.
+ * F_parameter (with error bit) if a parameter is invalid.
+ *
+ * Errors (with error bit) from: f_memory_resize().
+ */
+#ifndef _di_f_sockets_increase_by_
+ extern f_status_t f_sockets_increase_by(const f_number_unsigned_t amount, f_sockets_t * const sockets);
+#endif // _di_f_sockets_increase_by_
+
+/**
+ * Resize the string sockets array.
+ *
+ * @param length
+ * The new size to use.
+ * @param sockets
+ * The string sockets array to adjust.
+ *
+ * @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_sockets_resize_
+ extern f_status_t f_sockets_resize(const f_number_unsigned_t length, f_sockets_t * const sockets);
+#endif // _di_f_sockets_resize_
+
+/**
+ * Resize the string socketss array.
+ *
+ * @param length
+ * The new size to use.
+ * @param socketss
+ * The string socketss 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().
+ * Errors (with error bit) from: f_memory_destroy().
+ */
+#ifndef _di_f_socketss_adjust_
+ extern f_status_t f_socketss_adjust(const f_number_unsigned_t length, f_socketss_t * const socketss);
+#endif // _di_f_socketss_adjust_
+
+/**
+ * Append the single source sockets onto the destination.
+ *
+ * @param source
+ * The source sockets to append.
+ * @param destination
+ * The destination ranges the source is appended onto.
+ *
+ * @return
+ * F_none on success.
+ * F_data_not on success, but there is nothing to append (size == 0).
+ *
+ * F_parameter (with error bit) if a parameter is invalid.
+ *
+ * Errors (with error bit) from: f_memory_resize().
+ */
+#ifndef _di_f_socketss_append_
+ extern f_status_t f_socketss_append(const f_sockets_t source, f_socketss_t * const destination);
+#endif // _di_f_socketss_append_
+
+/**
+ * Append the source socketss onto the destination.
+ *
+ * @param source
+ * The source socketss to append.
+ * @param destination
+ * The destination ranges the source is appended onto.
+ *
+ * @return
+ * F_none on success.
+ * F_data_not on success, but there is nothing to append (size == 0).
+ *
+ * F_parameter (with error bit) if a parameter is invalid.
+ *
+ * Errors (with error bit) from: f_memory_resize().
+ */
+#ifndef _di_f_socketss_append_all_
+ extern f_status_t f_socketss_append_all(const f_socketss_t source, f_socketss_t * const destination);
+#endif // _di_f_socketss_append_all_
+
+/**
+ * Resize the string socketss 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 socketss
+ * The string socketss 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().
+ * Errors (with error bit) from: f_memory_destroy().
+ */
+#ifndef _di_f_socketss_decimate_by_
+ extern f_status_t f_socketss_decimate_by(const f_number_unsigned_t amount, f_socketss_t * const socketss);
+#endif // _di_f_socketss_decimate_by_
+
+/**
+ * Resize the string socketss 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 socketss
+ * The string socketss 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_delete().
+ * Errors (with error bit) from: f_memory_resize().
+ */
+#ifndef _di_f_socketss_decrease_by_
+ extern f_status_t f_socketss_decrease_by(const f_number_unsigned_t amount, f_socketss_t * const socketss);
+#endif // _di_f_socketss_decrease_by_
+
+/**
+ * Increase the size of the string socketss array, but only if necessary.
+ *
+ * If the given length is too large for the buffer, then attempt to set max buffer size (F_number_t_size_unsigned_d).
+ * If already set to the maximum buffer size, then the resize will fail.
+ *
+ * @param step
+ * The allocation step to use.
+ * Must be greater than 0.
+ * @param socketss
+ * The string socketss 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_parameter (with error bit) if a parameter is invalid.
+ *
+ * Errors (with error bit) from: f_memory_resize().
+ */
+#ifndef _di_f_socketss_increase_
+ extern f_status_t f_socketss_increase(const f_number_unsigned_t step, f_socketss_t * const socketss);
+#endif // _di_f_socketss_increase_
+
+/**
+ * Resize the string socketss array to a larger size.
+ *
+ * This will resize making the array larger based on the given length.
+ * If the given length is too large for the buffer, then attempt to set max buffer size (F_number_t_size_unsigned_d).
+ * 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 socketss
+ * The string socketss 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_array_too_large (with error bit) if the new array length is too large.
+ * F_parameter (with error bit) if a parameter is invalid.
+ *
+ * Errors (with error bit) from: f_memory_resize().
+ */
+#ifndef _di_f_socketss_increase_by_
+ extern f_status_t f_socketss_increase_by(const f_number_unsigned_t amount, f_socketss_t * const socketss);
+#endif // _di_f_socketss_increase_by_
+
+/**
+ * Resize the string socketss array.
+ *
+ * @param length
+ * The new size to use.
+ * @param socketss
+ * The string socketss array to adjust.
+ *
+ * @return
+ * F_none on success.
+ *
+ * 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_socketss_resize_
+ extern f_status_t f_socketss_resize(const f_number_unsigned_t length, f_socketss_t * const socketss);
+#endif // _di_f_socketss_resize_
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
+
+#endif // _F_socket_socket_h
build_libraries -lc
build_libraries-individual -lf_memory -lf_string
-build_sources_library socket.c
+build_sources_library socket.c socket/socket.c socket/private-socket.c
-build_sources_headers socket.h socket/common.h
+build_sources_headers socket.h socket/socket.h socket/common.h
build_script yes
build_shared yes
build_libraries -lc
build_libraries-individual -lf_memory -lf_string
-build_sources_library socket.c ../../tests/unit/c/mock-socket.c
+build_sources_library socket.c socket/socket.c socket/private-socket.c ../../tests/unit/c/mock-socket.c
-build_sources_headers socket.h socket/common.h
+build_sources_headers socket.h socket/socket.h socket/common.h
build_script yes
build_shared yes
build_libraries-individual -lf_memory -lf_string -lf_type_array -lf_socket
build_sources_program test-socket-accept.c test-socket-bind.c test-socket-bind_local.c test-socket-connect.c test-socket-create.c test-socket-create_pair.c test-socket-disconnect.c test-socket-listen.c test-socket-name_host.c test-socket-name_peer.c test-socket-option_get.c test-socket-option_set.c test-socket-read.c test-socket-read_message.c test-socket-read_stream.c test-socket-write.c test-socket-write_message.c test-socket-write_stream.c
+build_sources_program test-socket-sockets_adjust.c test-socket-sockets_append.c test-socket-sockets_append_all.c test-socket-sockets_decimate_by.c test-socket-sockets_decrease_by.c test-socket-sockets_increase.c test-socket-sockets_increase_by.c test-socket-sockets_resize.c
+build_sources_program test-socket-socketss_adjust.c test-socket-socketss_append.c test-socket-socketss_append_all.c test-socket-socketss_decimate_by.c test-socket-socketss_decrease_by.c test-socket-socketss_increase.c test-socket-socketss_increase_by.c test-socket-socketss_resize.c
+
build_sources_program test-socket.c
build_script no
--- /dev/null
+#include "test-socket.h"
+#include "test-socket-sockets_adjust.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void test__f_socket_sockets_adjust__parameter_checking(void **state) {
+
+ const int length = 5;
+ f_sockets_t data = f_sockets_t_initialize;
+
+ {
+ const f_status_t status = f_sockets_adjust(length, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, 0);
+ }
+
+ assert_null(data.array);
+}
+
+void test__f_socket_sockets_adjust__works(void **state) {
+
+ const int length = 5;
+ f_sockets_t data = f_sockets_t_initialize;
+
+ {
+ const f_status_t status = f_sockets_adjust(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ free((void *) data.array);
+}
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
--- /dev/null
+/**
+ * FLL - Level 0
+ *
+ * Project: Socket
+ * API Version: 0.7
+ * Licenses: lgpl-2.1-or-later
+ *
+ * Test the array types in the type project.
+ */
+#ifndef _TEST__F_socket__sockets_adjust
+#define _TEST__F_socket__sockets_adjust
+
+/**
+ * Test that the function correctly fails on invalid parameter.
+ *
+ * @see f_sockets_adjust()
+ */
+extern void test__f_socket_sockets_adjust__parameter_checking(void **state);
+
+/**
+ * Test that the function works.
+ *
+ * @see f_sockets_adjust()
+ */
+extern void test__f_socket_sockets_adjust__works(void **state);
+
+#endif // _TEST__F_socket__sockets_adjust
--- /dev/null
+#include "test-socket.h"
+#include "test-socket-sockets_append.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void test__f_socket_sockets_append__parameter_checking(void **state) {
+
+ const f_socket_t data = f_socket_t_initialize;
+
+ {
+ const f_status_t status = f_sockets_append(data, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ }
+}
+
+void test__f_socket_sockets_append__works(void **state) {
+
+ f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
+ const f_socket_t source = macro_f_socket_t_initialize_3(1, 2, 3, 4, 0, 0, test);
+ f_sockets_t destination = f_sockets_t_initialize;
+
+ {
+ const f_status_t status = f_sockets_append(source, &destination);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(destination.used, 1);
+ assert_int_equal(destination.array[0].id, source.id);
+ assert_int_equal(destination.array[0].domain, source.domain);
+ assert_int_equal(destination.array[0].protocol, source.protocol);
+ assert_int_equal(destination.array[0].type, source.type);
+ assert_int_equal(destination.array[0].name.used, source.name.used);
+
+ assert_string_equal(destination.array[0].name.string, source.name.string);
+ }
+
+ free((void *) destination.array);
+}
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
--- /dev/null
+/**
+ * FLL - Level 0
+ *
+ * Project: Socket
+ * API Version: 0.7
+ * Licenses: lgpl-2.1-or-later
+ *
+ * Test the array types in the type project.
+ */
+#ifndef _TEST__F_socket__sockets_append
+#define _TEST__F_socket__sockets_append
+
+/**
+ * Test that the function correctly fails on invalid parameter.
+ *
+ * @see f_sockets_append()
+ */
+extern void test__f_socket_sockets_append__parameter_checking(void **state);
+
+/**
+ * Test that the function works.
+ *
+ * @see f_sockets_append()
+ */
+extern void test__f_socket_sockets_append__works(void **state);
+
+#endif // _TEST__F_socket__sockets_append
--- /dev/null
+#include "test-socket.h"
+#include "test-socket-sockets_append_all.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void test__f_socket_sockets_append_all__parameter_checking(void **state) {
+
+ const f_sockets_t data = f_sockets_t_initialize;
+
+ {
+ const f_status_t status = f_sockets_append_all(data, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ }
+}
+
+void test__f_socket_sockets_append_all__returns_data_not(void **state) {
+
+ const int length = 5;
+ f_sockets_t source = f_sockets_t_initialize;
+ f_sockets_t destination = f_sockets_t_initialize;
+
+ {
+ const f_status_t status = f_sockets_resize(length, &source);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(source.used, 0);
+ assert_int_equal(source.size, length);
+ }
+
+ {
+ const f_status_t status = f_sockets_append_all(source, &destination);
+
+ assert_int_equal(status, F_data_not);
+ assert_int_equal(destination.used, 0);
+ assert_int_equal(destination.size, 0);
+ assert_null(destination.array);
+ }
+
+ free((void *) source.array);
+}
+
+void test__f_socket_sockets_append_all__works(void **state) {
+
+ const int length = 5;
+ const int length_used = 2;
+
+ f_string_static_t tests[] = {
+ macro_f_string_static_t_initialize_1("test_1", 0, 6),
+ macro_f_string_static_t_initialize_1("test_2", 0, 6),
+ };
+
+ f_socket_t sources[] = {
+ macro_f_socket_t_initialize_3(1, 2, 3, 4, 0, 0, tests[0]),
+ macro_f_socket_t_initialize_3(5, 6, 7, 8, 0, 0, tests[1]),
+ };
+
+ f_sockets_t source = f_sockets_t_initialize;
+ f_sockets_t destination = f_sockets_t_initialize;
+
+ {
+ const f_status_t status = f_sockets_resize(length, &source);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(source.used, 0);
+ assert_int_equal(source.size, length);
+ }
+
+ for (; source.used < length_used; ++source.used) {
+ source.array[source.used] = sources[source.used];
+ //memcpy((void *) &source.array[source.used], (void *) &sources[source.used], sizeof(f_sockets_t));
+ } // for
+
+ {
+ const f_status_t status = f_sockets_append_all(source, &destination);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(destination.used, source.used);
+ assert_int_equal(destination.size, source.used);
+
+ for (f_number_unsigned_t i = 0; i < source.used; ++i) {
+
+ assert_int_equal(destination.array[i].id, sources[i].id);
+ assert_int_equal(destination.array[i].domain, sources[i].domain);
+ assert_int_equal(destination.array[i].protocol, sources[i].protocol);
+ assert_int_equal(destination.array[i].type, sources[i].type);
+ assert_int_equal(destination.array[i].name.used, sources[i].name.used);
+
+ assert_string_equal(destination.array[i].name.string, sources[i].name.string);
+ } // for
+ }
+
+ free((void *) source.array);
+ free((void *) destination.array);
+}
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
--- /dev/null
+/**
+ * FLL - Level 0
+ *
+ * Project: Socket
+ * API Version: 0.7
+ * Licenses: lgpl-2.1-or-later
+ *
+ * Test the array types in the type project.
+ */
+#ifndef _TEST__F_socket__sockets_append_all
+#define _TEST__F_socket__sockets_append_all
+
+/**
+ * Test that the function correctly fails on invalid parameter.
+ *
+ * @see f_sockets_append_all()
+ */
+extern void test__f_socket_sockets_append_all__parameter_checking(void **state);
+
+/**
+ * Test that the function returns F_data_not.
+ *
+ * @see f_sockets_append_all()
+ */
+extern void test__f_socket_sockets_append_all__returns_data_not(void **state);
+
+/**
+ * Test that the function works.
+ *
+ * @see f_sockets_append_all()
+ */
+extern void test__f_socket_sockets_append_all__works(void **state);
+
+#endif // _TEST__F_socket__sockets_append_all
--- /dev/null
+#include "test-socket.h"
+#include "test-socket-sockets_decimate_by.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void test__f_socket_sockets_decimate_by__parameter_checking(void **state) {
+
+ const int length = 5;
+ f_sockets_t data = f_sockets_t_initialize;
+
+ {
+ const f_status_t status = f_sockets_decimate_by(length, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, 0);
+ }
+
+ assert_null(data.array);
+}
+
+void test__f_socket_sockets_decimate_by__returns_data_not(void **state) {
+
+ const int length = 5;
+ f_sockets_t data = f_sockets_t_initialize;
+
+ {
+ const f_status_t status = f_sockets_resize(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ {
+ const f_status_t status = f_sockets_decimate_by(0, &data);
+
+ assert_int_equal(status, F_data_not);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ free((void *) data.array);
+}
+
+void test__f_socket_sockets_decimate_by__works(void **state) {
+
+ const int length = 5;
+ f_sockets_t data = f_sockets_t_initialize;
+
+ {
+ const f_status_t status = f_sockets_resize(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ {
+ const f_status_t status = f_sockets_decimate_by(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, 0);
+ }
+
+ assert_null(data.array);
+}
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
--- /dev/null
+/**
+ * FLL - Level 0
+ *
+ * Project: Socket
+ * API Version: 0.7
+ * Licenses: lgpl-2.1-or-later
+ *
+ * Test the array types in the type project.
+ */
+#ifndef _TEST__F_socket__sockets_decimate_by
+#define _TEST__F_socket__sockets_decimate_by
+
+/**
+ * Test that the function correctly fails on invalid parameter.
+ *
+ * @see f_sockets_decimate_by()
+ */
+extern void test__f_socket_sockets_decimate_by__parameter_checking(void **state);
+
+/**
+ * Test that the function returns F_data_not.
+ *
+ * @see f_sockets_decimate_by()
+ */
+extern void test__f_socket_sockets_decimate_by__returns_data_not(void **state);
+
+/**
+ * Test that the function works.
+ *
+ * @see f_sockets_decimate_by()
+ */
+extern void test__f_socket_sockets_decimate_by__works(void **state);
+
+#endif // _TEST__F_socket__sockets_decimate_by
--- /dev/null
+#include "test-socket.h"
+#include "test-socket-sockets_decrease_by.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void test__f_socket_sockets_decrease_by__parameter_checking(void **state) {
+
+ const int length = 5;
+ f_sockets_t data = f_sockets_t_initialize;
+
+ {
+ const f_status_t status = f_sockets_decrease_by(length, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, 0);
+ }
+
+ assert_null(data.array);
+}
+
+void test__f_socket_sockets_decrease_by__returns_data_not(void **state) {
+
+ const int length = 5;
+ f_sockets_t data = f_sockets_t_initialize;
+
+ {
+ const f_status_t status = f_sockets_resize(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ {
+ const f_status_t status = f_sockets_decrease_by(0, &data);
+
+ assert_int_equal(status, F_data_not);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ free((void *) data.array);
+}
+
+void test__f_socket_sockets_decrease_by__works(void **state) {
+
+ const int length = 5;
+ f_sockets_t data = f_sockets_t_initialize;
+
+ {
+ const f_status_t status = f_sockets_resize(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ {
+ const f_status_t status = f_sockets_decrease_by(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, 0);
+ }
+
+ assert_null(data.array);
+}
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
--- /dev/null
+/**
+ * FLL - Level 0
+ *
+ * Project: Socket
+ * API Version: 0.7
+ * Licenses: lgpl-2.1-or-later
+ *
+ * Test the array types in the type project.
+ */
+#ifndef _TEST__F_socket__sockets_decrease_by
+#define _TEST__F_socket__sockets_decrease_by
+
+/**
+ * Test that the function correctly fails on invalid parameter.
+ *
+ * @see f_sockets_decrease_by()
+ */
+extern void test__f_socket_sockets_decrease_by__parameter_checking(void **state);
+
+/**
+ * Test that the function returns F_data_not.
+ *
+ * @see f_sockets_decrease_by()
+ */
+extern void test__f_socket_sockets_decrease_by__returns_data_not(void **state);
+
+/**
+ * Test that the function works.
+ *
+ * @see f_sockets_decrease_by()
+ */
+extern void test__f_socket_sockets_decrease_by__works(void **state);
+
+#endif // _TEST__F_socket__sockets_decrease_by
--- /dev/null
+#include "test-socket.h"
+#include "test-socket-sockets_increase.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void test__f_socket_sockets_increase__parameter_checking(void **state) {
+
+ const int length = 5;
+ f_sockets_t data = f_sockets_t_initialize;
+
+ {
+ const f_status_t status = f_sockets_increase(length, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, 0);
+ }
+
+ free((void *) data.array);
+}
+
+void test__f_socket_sockets_increase__returns_data_not(void **state) {
+
+ const int length = 5;
+ f_sockets_t data = f_sockets_t_initialize;
+
+ {
+ const f_status_t status = f_sockets_resize(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ {
+ const f_status_t status = f_sockets_increase(length, &data);
+
+ assert_int_equal(status, F_data_not);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ free((void *) data.array);
+}
+
+void test__f_socket_sockets_increase__works(void **state) {
+
+ const int length = 5;
+ f_sockets_t data = f_sockets_t_initialize;
+
+ {
+ const f_status_t status = f_sockets_resize(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ {
+ data.used = length;
+
+ const f_status_t status = f_sockets_increase(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, length);
+ assert_in_range(data.size, length + 1, length + 1 + F_memory_default_allocation_small_d);
+ }
+
+ free((void *) data.array);
+}
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
--- /dev/null
+/**
+ * FLL - Level 0
+ *
+ * Project: Socket
+ * API Version: 0.7
+ * Licenses: lgpl-2.1-or-later
+ *
+ * Test the array types in the type project.
+ */
+#ifndef _TEST__F_socket__sockets_increase
+#define _TEST__F_socket__sockets_increase
+
+/**
+ * Test that the function correctly fails on invalid parameter.
+ *
+ * @see f_sockets_increase()
+ */
+extern void test__f_socket_sockets_increase__parameter_checking(void **state);
+
+/**
+ * Test that the function returns F_data_not.
+ *
+ * @see f_sockets_increase()
+ */
+extern void test__f_socket_sockets_increase__returns_data_not(void **state);
+
+/**
+ * Test that the function works.
+ *
+ * @see f_sockets_increase()
+ */
+extern void test__f_socket_sockets_increase__works(void **state);
+
+#endif // _TEST__F_socket__sockets_increase
--- /dev/null
+#include "test-socket.h"
+#include "test-socket-sockets_increase_by.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void test__f_socket_sockets_increase_by__parameter_checking(void **state) {
+
+ const int length = 5;
+ f_sockets_t data = f_sockets_t_initialize;
+
+ {
+ const f_status_t status = f_sockets_increase_by(length, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, 0);
+ }
+
+ assert_null(data.array);
+}
+
+void test__f_socket_sockets_increase_by__returns_data_not(void **state) {
+
+ const int length = 5;
+ f_sockets_t data = f_sockets_t_initialize;
+
+ {
+ const f_status_t status = f_sockets_resize(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ {
+ const f_status_t status = f_sockets_increase_by(0, &data);
+
+ assert_int_equal(status, F_data_not);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ free((void *) data.array);
+}
+
+void test__f_socket_sockets_increase_by__works(void **state) {
+
+ const int length = 5;
+ f_sockets_t data = f_sockets_t_initialize;
+
+ {
+ const f_status_t status = f_sockets_resize(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ {
+ data.used = length;
+
+ const f_status_t status = f_sockets_increase_by(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, length);
+ assert_int_equal(data.size, length * 2);
+ }
+
+ free((void *) data.array);
+}
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
--- /dev/null
+/**
+ * FLL - Level 0
+ *
+ * Project: Socket
+ * API Version: 0.7
+ * Licenses: lgpl-2.1-or-later
+ *
+ * Test the array types in the type project.
+ */
+#ifndef _TEST__F_socket__sockets_increase_by
+#define _TEST__F_socket__sockets_increase_by
+
+/**
+ * Test that the function correctly fails on invalid parameter.
+ *
+ * @see f_sockets_increase_by()
+ */
+extern void test__f_socket_sockets_increase_by__parameter_checking(void **state);
+
+/**
+ * Test that the function returns F_data_not.
+ *
+ * @see f_sockets_increase_by()
+ */
+extern void test__f_socket_sockets_increase_by__returns_data_not(void **state);
+
+/**
+ * Test that the function works.
+ *
+ * @see f_sockets_increase_by()
+ */
+extern void test__f_socket_sockets_increase_by__works(void **state);
+
+#endif // _TEST__F_socket__sockets_increase_by
--- /dev/null
+#include "test-socket.h"
+#include "test-socket-sockets_resize.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void test__f_socket_sockets_resize__parameter_checking(void **state) {
+
+ const int length = 5;
+ f_sockets_t data = f_sockets_t_initialize;
+
+ {
+ const f_status_t status = f_sockets_resize(length, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, 0);
+ }
+
+ assert_null(data.array);
+}
+
+void test__f_socket_sockets_resize__works(void **state) {
+
+ const int length = 5;
+ f_sockets_t data = f_sockets_t_initialize;
+
+ {
+ const f_status_t status = f_sockets_resize(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ free((void *) data.array);
+}
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
--- /dev/null
+/**
+ * FLL - Level 0
+ *
+ * Project: Socket
+ * API Version: 0.7
+ * Licenses: lgpl-2.1-or-later
+ *
+ * Test the array types in the type project.
+ */
+#ifndef _TEST__F_socket__sockets_resize
+#define _TEST__F_socket__sockets_resize
+
+/**
+ * Test that the function correctly fails on invalid parameter.
+ *
+ * @see f_sockets_resize()
+ */
+extern void test__f_socket_sockets_resize__parameter_checking(void **state);
+
+/**
+ * Test that the function works.
+ *
+ * @see f_sockets_resize()
+ */
+extern void test__f_socket_sockets_resize__works(void **state);
+
+#endif // _TEST__F_socket__sockets_resize
--- /dev/null
+#include "test-socket.h"
+#include "test-socket-socketss_adjust.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void test__f_socket_socketss_adjust__parameter_checking(void **state) {
+
+ const int length = 5;
+ f_socketss_t data = f_socketss_t_initialize;
+
+ {
+ const f_status_t status = f_socketss_adjust(length, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, 0);
+ }
+
+ assert_null(data.array);
+}
+
+void test__f_socket_socketss_adjust__works(void **state) {
+
+ const int length = 5;
+ f_socketss_t data = f_socketss_t_initialize;
+
+ {
+ const f_status_t status = f_socketss_adjust(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ free((void *) data.array);
+}
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
--- /dev/null
+/**
+ * FLL - Level 0
+ *
+ * Project: Socket
+ * API Version: 0.7
+ * Licenses: lgpl-2.1-or-later
+ *
+ * Test the array types in the type project.
+ */
+#ifndef _TEST__F_socket__socketss_adjust
+#define _TEST__F_socket__socketss_adjust
+
+/**
+ * Test that the function correctly fails on invalid parameter.
+ *
+ * @see f_socketss_adjust()
+ */
+extern void test__f_socket_socketss_adjust__parameter_checking(void **state);
+
+/**
+ * Test that the function returns F_data_not.
+ *
+ * @see f_socketss_increase_by()
+ */
+extern void test__f_socket_socketss_increase_by__returns_data_not(void **state);
+
+/**
+ * Test that the function works.
+ *
+ * @see f_socketss_adjust()
+ */
+extern void test__f_socket_socketss_adjust__works(void **state);
+
+#endif // _TEST__F_socket__socketss_adjust
--- /dev/null
+#include "test-socket.h"
+#include "test-socket-socketss_append.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void test__f_socket_socketss_append__parameter_checking(void **state) {
+
+ f_sockets_t data = f_sockets_t_initialize;
+
+ {
+ const f_status_t status = f_socketss_append(data, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ }
+}
+
+void test__f_socket_socketss_append__returns_data_not(void **state) {
+
+ const int length = 5;
+ f_sockets_t source = f_sockets_t_initialize;
+ f_socketss_t destination = f_socketss_t_initialize;
+
+ {
+ const f_status_t status = f_sockets_resize(length, &source);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(source.used, 0);
+ assert_int_equal(source.size, length);
+ }
+
+ {
+ const f_status_t status = f_socketss_append(source, &destination);
+
+ assert_int_equal(status, F_data_not);
+ assert_int_equal(destination.used, 0);
+ assert_int_equal(destination.size, 0);
+ assert_null(destination.array);
+ }
+
+ free((void *) source.array);
+}
+
+void test__f_socket_socketss_append__works(void **state) {
+
+ const int length = 5;
+
+ f_string_static_t tests[] = {
+ macro_f_string_static_t_initialize_1("test_1", 0, 6),
+ macro_f_string_static_t_initialize_1("test_2", 0, 6),
+ macro_f_string_static_t_initialize_1("test_3", 0, 6),
+ macro_f_string_static_t_initialize_1("test_4", 0, 6),
+ macro_f_string_static_t_initialize_1("test_5", 0, 6),
+ };
+
+ f_socket_t sources[] = {
+ macro_f_socket_t_initialize_3(1, 2, 3, 4, 0, 0, tests[0]),
+ macro_f_socket_t_initialize_3(5, 6, 7, 8, 0, 0, tests[1]),
+ macro_f_socket_t_initialize_3(9, 10, 11, 12, 0, 0, tests[2]),
+ macro_f_socket_t_initialize_3(13, 14, 15, 16, 0, 0, tests[3]),
+ macro_f_socket_t_initialize_3(17, 18, 19, 20, 0, 0, tests[4]),
+ };
+
+ f_sockets_t source = f_sockets_t_initialize;
+ f_socketss_t destination = f_socketss_t_initialize;
+
+ {
+ const f_status_t status = f_sockets_resize(length, &source);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(source.used, 0);
+ assert_int_equal(source.size, length);
+ }
+
+ for (; source.used < length; ++source.used) {
+ source.array[source.used] = sources[source.used];
+ } // for
+
+ {
+ const f_status_t status = f_socketss_append(source, &destination);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(destination.used, 1);
+ assert_int_equal(destination.array[0].used, source.used);
+ assert_int_equal(destination.array[0].size, source.used);
+
+ for (f_number_unsigned_t i = 0; i < destination.array[0].used; ++i) {
+
+ assert_int_equal(destination.array[0].array[i].id, sources[i].id);
+ assert_int_equal(destination.array[0].array[i].domain, sources[i].domain);
+ assert_int_equal(destination.array[0].array[i].protocol, sources[i].protocol);
+ assert_int_equal(destination.array[0].array[i].type, sources[i].type);
+ assert_int_equal(destination.array[0].array[i].name.used, sources[i].name.used);
+
+ assert_string_equal(destination.array[0].array[i].name.string, sources[i].name.string);
+ } // for
+ }
+
+ for (f_number_unsigned_t i = 0; i < destination.used; ++i) {
+ free((void *) destination.array[i].array);
+ } // for
+
+ free((void *) source.array);
+ free((void *) destination.array);
+}
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
--- /dev/null
+/**
+ * FLL - Level 0
+ *
+ * Project: Socket
+ * API Version: 0.7
+ * Licenses: lgpl-2.1-or-later
+ *
+ * Test the array types in the type project.
+ */
+#ifndef _TEST__F_socket__socketss_append
+#define _TEST__F_socket__socketss_append
+
+/**
+ * Test that the function correctly fails on invalid parameter.
+ *
+ * @see f_socketss_append()
+ */
+extern void test__f_socket_socketss_append__parameter_checking(void **state);
+
+/**
+ * Test that the function returns F_data_not.
+ *
+ * @see f_socketss_append()
+ */
+extern void test__f_socket_socketss_append__returns_data_not(void **state);
+
+/**
+ * Test that the function works.
+ *
+ * @see f_socketss_append()
+ */
+extern void test__f_socket_socketss_append__works(void **state);
+
+#endif // _TEST__F_socket__socketss_append
--- /dev/null
+#include "test-socket.h"
+#include "test-socket-socketss_append_all.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void test__f_socket_socketss_append_all__parameter_checking(void **state) {
+
+ const f_socketss_t data = f_socketss_t_initialize;
+
+ {
+ const f_status_t status = f_socketss_append_all(data, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ }
+}
+
+void test__f_socket_socketss_append_all__returns_data_not(void **state) {
+
+ const int length = 5;
+ f_socketss_t source = f_socketss_t_initialize;
+ f_socketss_t destination = f_socketss_t_initialize;
+
+ {
+ const f_status_t status = f_socketss_resize(length, &source);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(source.used, 0);
+ assert_int_equal(source.size, length);
+ }
+
+ {
+ const f_status_t status = f_socketss_append_all(source, &destination);
+
+ assert_int_equal(status, F_data_not);
+ assert_int_equal(destination.used, 0);
+ assert_int_equal(destination.size, 0);
+ assert_null(destination.array);
+ }
+
+ free((void *) source.array);
+}
+
+void test__f_socket_socketss_append_all__works(void **state) {
+
+ const int length = 5;
+ const int length_inner = 2;
+
+ f_string_static_t tests[] = {
+ macro_f_string_static_t_initialize_1("test_1", 0, 6),
+ macro_f_string_static_t_initialize_1("test_2", 0, 6),
+ };
+
+ f_socket_t sources[] = {
+ macro_f_socket_t_initialize_3(1, 2, 3, 4, 0, 0, tests[0]),
+ macro_f_socket_t_initialize_3(5, 6, 7, 8, 0, 0, tests[1]),
+ };
+
+ f_socketss_t source = f_socketss_t_initialize;
+ f_socketss_t destination = f_socketss_t_initialize;
+
+ {
+ const f_status_t status = f_socketss_resize(length, &source);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(source.used, 0);
+ assert_int_equal(source.size, length);
+ }
+
+ {
+ for (; source.used < length; ++source.used) {
+
+ const f_status_t status = f_sockets_resize(length_inner, &source.array[source.used]);
+
+ assert_int_equal(status, F_none);
+
+ for (f_number_unsigned_t i = 0; i < length_inner; ++i) {
+ source.array[source.used].array[source.array[source.used].used++] = sources[i];
+ } // for
+ } // for
+ }
+
+ {
+ const f_status_t status = f_socketss_append_all(source, &destination);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(destination.used, source.used);
+ assert_int_equal(destination.size, source.used);
+
+ for (f_number_unsigned_t i = 0; i < destination.used; ++i) {
+
+ assert_int_equal(destination.array[i].used, length_inner);
+ assert_int_equal(destination.array[i].size, length_inner);
+
+ for (f_number_unsigned_t j = 0; j < length_inner; ++j) {
+
+ assert_int_equal(destination.array[i].array[j].id, sources[j].id);
+ assert_int_equal(destination.array[i].array[j].domain, sources[j].domain);
+ assert_int_equal(destination.array[i].array[j].protocol, sources[j].protocol);
+ assert_int_equal(destination.array[i].array[j].type, sources[j].type);
+ assert_int_equal(destination.array[i].array[j].name.used, sources[j].name.used);
+
+ assert_string_equal(destination.array[i].array[j].name.string, sources[j].name.string);
+ } // for
+ } // for
+ }
+
+ for (f_number_unsigned_t i = 0; i < source.used; ++i) {
+ free((void *) source.array[i].array);
+ } // for
+
+ for (f_number_unsigned_t i = 0; i < destination.used; ++i) {
+ free((void *) destination.array[i].array);
+ } // for
+
+ free((void *) source.array);
+ free((void *) destination.array);
+}
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
--- /dev/null
+/**
+ * FLL - Level 0
+ *
+ * Project: Socket
+ * API Version: 0.7
+ * Licenses: lgpl-2.1-or-later
+ *
+ * Test the array types in the type project.
+ */
+#ifndef _TEST__F_socket__socketss_append_all
+#define _TEST__F_socket__socketss_append_all
+
+/**
+ * Test that the function correctly fails on invalid parameter.
+ *
+ * @see f_socketss_append_all()
+ */
+extern void test__f_socket_socketss_append_all__parameter_checking(void **state);
+
+/**
+ * Test that the function returns F_data_not.
+ *
+ * @see f_socketss_append_all()
+ */
+extern void test__f_socket_socketss_append_all__returns_data_not(void **state);
+
+/**
+ * Test that the function works.
+ *
+ * @see f_socketss_append_all()
+ */
+extern void test__f_socket_socketss_append_all__works(void **state);
+
+#endif // _TEST__F_socket__socketss_append_all
--- /dev/null
+#include "test-socket.h"
+#include "test-socket-socketss_decimate_by.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void test__f_socket_socketss_decimate_by__parameter_checking(void **state) {
+
+ const int length = 5;
+ f_socketss_t data = f_sockets_t_initialize;
+
+ {
+ const f_status_t status = f_socketss_decimate_by(length, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, 0);
+ }
+
+ assert_null(data.array);
+}
+
+void test__f_socket_socketss_decimate_by__returns_data_not(void **state) {
+
+ const int length = 5;
+ f_socketss_t data = f_socketss_t_initialize;
+
+ {
+ const f_status_t status = f_socketss_resize(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ {
+ const f_status_t status = f_socketss_decimate_by(0, &data);
+
+ assert_int_equal(status, F_data_not);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ free((void *) data.array);
+}
+
+void test__f_socket_socketss_decimate_by__works(void **state) {
+
+ const int length = 5;
+ f_socketss_t data = f_sockets_t_initialize;
+
+ {
+ const f_status_t status = f_socketss_resize(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ {
+ const f_status_t status = f_socketss_decimate_by(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, 0);
+ }
+
+ assert_null(data.array);
+}
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
--- /dev/null
+/**
+ * FLL - Level 0
+ *
+ * Project: Socket
+ * API Version: 0.7
+ * Licenses: lgpl-2.1-or-later
+ *
+ * Test the array types in the type project.
+ */
+#ifndef _TEST__F_socket__socketss_decimate_by
+#define _TEST__F_socket__socketss_decimate_by
+
+/**
+ * Test that the function correctly fails on invalid parameter.
+ *
+ * @see f_socketss_decimate_by()
+ */
+extern void test__f_socket_socketss_decimate_by__parameter_checking(void **state);
+
+/**
+ * Test that the function returns F_data_not.
+ *
+ * @see f_socket_socketss_decimate_by()
+ */
+extern void test__f_socket_socketss_decimate_by__returns_data_not(void **state);
+
+/**
+ * Test that the function works.
+ *
+ * @see f_socketss_decimate_by()
+ */
+extern void test__f_socket_socketss_decimate_by__works(void **state);
+
+#endif // _TEST__F_socket__socketss_decimate_by
--- /dev/null
+#include "test-socket.h"
+#include "test-socket-socketss_decrease_by.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void test__f_socket_socketss_decrease_by__parameter_checking(void **state) {
+
+ const int length = 5;
+ f_socketss_t data = f_sockets_t_initialize;
+
+ {
+ const f_status_t status = f_socketss_decrease_by(length, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, 0);
+ }
+
+ assert_null(data.array);
+}
+
+void test__f_socket_socketss_decrease_by__returns_data_not(void **state) {
+
+ const int length = 5;
+ f_socketss_t data = f_socketss_t_initialize;
+
+ {
+ const f_status_t status = f_socketss_resize(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ {
+ const f_status_t status = f_socketss_decrease_by(0, &data);
+
+ assert_int_equal(status, F_data_not);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ free((void *) data.array);
+}
+
+void test__f_socket_socketss_decrease_by__works(void **state) {
+
+ const int length = 5;
+ f_socketss_t data = f_sockets_t_initialize;
+
+ {
+ const f_status_t status = f_socketss_resize(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ {
+ const f_status_t status = f_socketss_decrease_by(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, 0);
+ }
+
+ assert_null(data.array);
+}
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
--- /dev/null
+/**
+ * FLL - Level 0
+ *
+ * Project: Socket
+ * API Version: 0.7
+ * Licenses: lgpl-2.1-or-later
+ *
+ * Test the array types in the type project.
+ */
+#ifndef _TEST__F_socket__socketss_decrease_by
+#define _TEST__F_socket__socketss_decrease_by
+
+/**
+ * Test that the function correctly fails on invalid parameter.
+ *
+ * @see f_socketss_decrease_by()
+ */
+extern void test__f_socket_socketss_decrease_by__parameter_checking(void **state);
+
+/**
+ * Test that the function returns F_data_not.
+ *
+ * @see f_socketss_decrease_by()
+ */
+extern void test__f_socket_socketss_decrease_by__returns_data_not(void **state);
+
+/**
+ * Test that the function works.
+ *
+ * @see f_socketss_decrease_by()
+ */
+extern void test__f_socket_socketss_decrease_by__works(void **state);
+
+#endif // _TEST__F_socket__socketss_decrease_by
--- /dev/null
+#include "test-socket.h"
+#include "test-socket-socketss_increase.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void test__f_socket_socketss_increase__parameter_checking(void **state) {
+
+ const int length = 5;
+ f_socketss_t data = f_sockets_t_initialize;
+
+ {
+ const f_status_t status = f_socketss_increase(length, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, 0);
+ }
+
+ free((void *) data.array);
+}
+
+void test__f_socket_socketss_increase__returns_data_not(void **state) {
+
+ const int length = 5;
+ f_socketss_t data = f_sockets_t_initialize;
+
+ {
+ const f_status_t status = f_socketss_resize(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ {
+ const f_status_t status = f_socketss_increase(length, &data);
+
+ assert_int_equal(status, F_data_not);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ free((void *) data.array);
+}
+
+void test__f_socket_socketss_increase__works(void **state) {
+
+ const int length = 5;
+ f_socketss_t data = f_sockets_t_initialize;
+
+ {
+ const f_status_t status = f_socketss_resize(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ {
+ data.used = length;
+
+ const f_status_t status = f_socketss_increase(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, length);
+ assert_in_range(data.size, length + 1, length + 1 + F_memory_default_allocation_small_d);
+ }
+
+ free((void *) data.array);
+}
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
--- /dev/null
+/**
+ * FLL - Level 0
+ *
+ * Project: Socket
+ * API Version: 0.7
+ * Licenses: lgpl-2.1-or-later
+ *
+ * Test the array types in the type project.
+ */
+#ifndef _TEST__F_socket__socketss_increase
+#define _TEST__F_socket__socketss_increase
+
+/**
+ * Test that the function correctly fails on invalid parameter.
+ *
+ * @see f_socketss_increase()
+ */
+extern void test__f_socket_socketss_increase__parameter_checking(void **state);
+
+/**
+ * Test that the function returns F_data_not.
+ *
+ * @see f_socketss_increase()
+ */
+extern void test__f_socket_socketss_increase__returns_data_not(void **state);
+
+/**
+ * Test that the function works.
+ *
+ * @see f_socketss_increase()
+ */
+extern void test__f_socket_socketss_increase__works(void **state);
+
+#endif // _TEST__F_socket__socketss_increase
--- /dev/null
+#include "test-socket.h"
+#include "test-socket-socketss_increase_by.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void test__f_socket_socketss_increase_by__parameter_checking(void **state) {
+
+ const int length = 5;
+ f_socketss_t data = f_sockets_t_initialize;
+
+ {
+ const f_status_t status = f_socketss_increase_by(length, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, 0);
+ }
+
+ assert_null(data.array);
+}
+
+void test__f_socket_socketss_increase_by__returns_data_not(void **state) {
+
+ const int length = 5;
+ f_socketss_t data = f_socketss_t_initialize;
+
+ {
+ const f_status_t status = f_socketss_resize(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ {
+ const f_status_t status = f_socketss_increase_by(0, &data);
+
+ assert_int_equal(status, F_data_not);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ {
+ const f_status_t status = f_socketss_increase_by(length, &data);
+
+ assert_int_equal(status, F_data_not);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ free((void *) data.array);
+}
+
+void test__f_socket_socketss_increase_by__works(void **state) {
+
+ const int length = 5;
+ f_socketss_t data = f_sockets_t_initialize;
+
+ {
+ const f_status_t status = f_socketss_resize(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ {
+ data.used = length;
+
+ const f_status_t status = f_socketss_increase_by(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, length);
+ assert_int_equal(data.size, length * 2);
+ }
+
+ free((void *) data.array);
+}
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
--- /dev/null
+/**
+ * FLL - Level 0
+ *
+ * Project: Socket
+ * API Version: 0.7
+ * Licenses: lgpl-2.1-or-later
+ *
+ * Test the array types in the type project.
+ */
+#ifndef _TEST__F_socket__socketss_increase_by
+#define _TEST__F_socket__socketss_increase_by
+
+/**
+ * Test that the function correctly fails on invalid parameter.
+ *
+ * @see f_socketss_increase_by()
+ */
+extern void test__f_socket_socketss_increase_by__parameter_checking(void **state);
+
+/**
+ * Test that the function returns F_data_not.
+ *
+ * @see f_socketss_increase_by()
+ */
+extern void test__f_socket_socketss_increase_by__returns_data_not(void **state);
+
+/**
+ * Test that the function works.
+ *
+ * @see f_socketss_increase_by()
+ */
+extern void test__f_socket_socketss_increase_by__works(void **state);
+
+#endif // _TEST__F_socket__socketss_increase_by
--- /dev/null
+#include "test-socket.h"
+#include "test-socket-socketss_resize.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void test__f_socket_socketss_resize__parameter_checking(void **state) {
+
+ const int length = 5;
+ f_socketss_t data = f_socketss_t_initialize;
+
+ {
+ const f_status_t status = f_socketss_resize(length, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, 0);
+ }
+
+ assert_null(data.array);
+}
+
+void test__f_socket_socketss_resize__works(void **state) {
+
+ const int length = 5;
+ f_socketss_t data = f_socketss_t_initialize;
+
+ {
+ const f_status_t status = f_socketss_resize(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ free((void *) data.array);
+}
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
--- /dev/null
+/**
+ * FLL - Level 0
+ *
+ * Project: Socket
+ * API Version: 0.7
+ * Licenses: lgpl-2.1-or-later
+ *
+ * Test the array types in the type project.
+ */
+#ifndef _TEST__F_socket__socketss_resize
+#define _TEST__F_socket__socketss_resize
+
+/**
+ * Test that the function correctly fails on invalid parameter.
+ *
+ * @see f_socketss_resize()
+ */
+extern void test__f_socket_socketss_resize__parameter_checking(void **state);
+
+/**
+ * Test that the function works.
+ *
+ * @see f_socketss_resize()
+ */
+extern void test__f_socket_socketss_resize__works(void **state);
+
+#endif // _TEST__F_socket__socketss_resize
cmocka_unit_test(test__f_socket_write_stream__fails),
cmocka_unit_test(test__f_socket_write_stream__works),
+ cmocka_unit_test(test__f_socket_sockets_append_all__returns_data_not),
+ cmocka_unit_test(test__f_socket_sockets_decimate_by__returns_data_not),
+ cmocka_unit_test(test__f_socket_sockets_decrease_by__returns_data_not),
+ cmocka_unit_test(test__f_socket_sockets_increase__returns_data_not),
+ cmocka_unit_test(test__f_socket_sockets_increase_by__returns_data_not),
+
+ cmocka_unit_test(test__f_socket_sockets_adjust__works),
+ cmocka_unit_test(test__f_socket_sockets_append__works),
+ cmocka_unit_test(test__f_socket_sockets_append_all__works),
+ cmocka_unit_test(test__f_socket_sockets_decimate_by__works),
+ cmocka_unit_test(test__f_socket_sockets_decrease_by__works),
+ cmocka_unit_test(test__f_socket_sockets_increase__works),
+ cmocka_unit_test(test__f_socket_sockets_increase_by__works),
+ cmocka_unit_test(test__f_socket_sockets_resize__works),
+
+ cmocka_unit_test(test__f_socket_socketss_append__returns_data_not),
+ cmocka_unit_test(test__f_socket_socketss_append_all__returns_data_not),
+ cmocka_unit_test(test__f_socket_socketss_decimate_by__returns_data_not),
+ cmocka_unit_test(test__f_socket_socketss_decrease_by__returns_data_not),
+ cmocka_unit_test(test__f_socket_socketss_increase__returns_data_not),
+ cmocka_unit_test(test__f_socket_socketss_increase_by__returns_data_not),
+
+ cmocka_unit_test(test__f_socket_socketss_adjust__works),
+ cmocka_unit_test(test__f_socket_socketss_append__works),
+ cmocka_unit_test(test__f_socket_socketss_append_all__works),
+ cmocka_unit_test(test__f_socket_socketss_decimate_by__works),
+ cmocka_unit_test(test__f_socket_socketss_decrease_by__works),
+ cmocka_unit_test(test__f_socket_socketss_increase__works),
+ cmocka_unit_test(test__f_socket_socketss_increase_by__works),
+ cmocka_unit_test(test__f_socket_socketss_resize__works),
+
#ifndef _di_level_0_parameter_checking_
cmocka_unit_test(test__f_socket_accept__parameter_checking),
cmocka_unit_test(test__f_socket_bind__parameter_checking),
cmocka_unit_test(test__f_socket_write__parameter_checking),
cmocka_unit_test(test__f_socket_write_message__parameter_checking),
cmocka_unit_test(test__f_socket_write_stream__parameter_checking),
+
+ cmocka_unit_test(test__f_socket_sockets_adjust__parameter_checking),
+ cmocka_unit_test(test__f_socket_sockets_append__parameter_checking),
+ cmocka_unit_test(test__f_socket_sockets_append_all__parameter_checking),
+ cmocka_unit_test(test__f_socket_sockets_decimate_by__parameter_checking),
+ cmocka_unit_test(test__f_socket_sockets_decrease_by__parameter_checking),
+ cmocka_unit_test(test__f_socket_sockets_increase__parameter_checking),
+ cmocka_unit_test(test__f_socket_sockets_increase_by__parameter_checking),
+ cmocka_unit_test(test__f_socket_sockets_resize__parameter_checking),
+
+ cmocka_unit_test(test__f_socket_socketss_adjust__parameter_checking),
+ cmocka_unit_test(test__f_socket_socketss_append__parameter_checking),
+ cmocka_unit_test(test__f_socket_socketss_append_all__parameter_checking),
+ cmocka_unit_test(test__f_socket_socketss_decimate_by__parameter_checking),
+ cmocka_unit_test(test__f_socket_socketss_decrease_by__parameter_checking),
+ cmocka_unit_test(test__f_socket_socketss_increase__parameter_checking),
+ cmocka_unit_test(test__f_socket_socketss_increase_by__parameter_checking),
+ cmocka_unit_test(test__f_socket_socketss_resize__parameter_checking),
#endif // _di_level_0_parameter_checking_
};
#include "test-socket-read.h"
#include "test-socket-read_message.h"
#include "test-socket-read_stream.h"
+#include "test-socket-sockets_adjust.h"
+#include "test-socket-sockets_append.h"
+#include "test-socket-sockets_append_all.h"
+#include "test-socket-sockets_decimate_by.h"
+#include "test-socket-sockets_decrease_by.h"
+#include "test-socket-sockets_increase.h"
+#include "test-socket-sockets_increase_by.h"
+#include "test-socket-sockets_resize.h"
+#include "test-socket-socketss_adjust.h"
+#include "test-socket-socketss_append.h"
+#include "test-socket-socketss_append_all.h"
+#include "test-socket-socketss_decimate_by.h"
+#include "test-socket-socketss_decrease_by.h"
+#include "test-socket-socketss_increase.h"
+#include "test-socket-socketss_increase_by.h"
+#include "test-socket-socketss_resize.h"
#include "test-socket-write.h"
#include "test-socket-write_message.h"
#include "test-socket-write_stream.h"
#endif
#ifndef _di_f_cells_adjust_
- f_status_t f_cells_adjust(const f_number_unsigned_t length, f_cells_t *cells) {
+ f_status_t f_cells_adjust(const f_number_unsigned_t length, f_cells_t * const cells) {
#ifndef _di_level_0_parameter_checking_
if (!cells) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_cells_adjust_
#ifndef _di_f_cells_append_
- f_status_t f_cells_append(const f_cell_t source, f_cells_t *destination) {
+ f_status_t f_cells_append(const f_cell_t source, f_cells_t * const destination) {
#ifndef _di_level_0_parameter_checking_
if (!destination) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_cells_append_
#ifndef _di_f_cells_append_all_
- f_status_t f_cells_append_all(const f_cells_t source, f_cells_t *destination) {
+ f_status_t f_cells_append_all(const f_cells_t source, f_cells_t * const destination) {
#ifndef _di_level_0_parameter_checking_
if (!destination) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_cells_append_all_
#ifndef _di_f_cells_decimate_by_
- f_status_t f_cells_decimate_by(const f_number_unsigned_t amount, f_cells_t *cells) {
+ f_status_t f_cells_decimate_by(const f_number_unsigned_t amount, f_cells_t * const cells) {
#ifndef _di_level_0_parameter_checking_
if (!cells) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_cells_decimate_by_
#ifndef _di_f_cells_decrease_by_
- f_status_t f_cells_decrease_by(const f_number_unsigned_t amount, f_cells_t *cells) {
+ f_status_t f_cells_decrease_by(const f_number_unsigned_t amount, f_cells_t * const cells) {
#ifndef _di_level_0_parameter_checking_
if (!cells) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_cells_decrease_by_
#ifndef _di_f_cells_increase_
- f_status_t f_cells_increase(const f_number_unsigned_t step, f_cells_t *cells) {
+ f_status_t f_cells_increase(const f_number_unsigned_t step, f_cells_t * const cells) {
#ifndef _di_level_0_parameter_checking_
if (!cells) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_cells_increase_
#ifndef _di_f_cells_increase_by_
- f_status_t f_cells_increase_by(const f_number_unsigned_t amount, f_cells_t *cells) {
+ f_status_t f_cells_increase_by(const f_number_unsigned_t amount, f_cells_t * const cells) {
#ifndef _di_level_0_parameter_checking_
if (!cells) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_cells_increase_by_
#ifndef _di_f_cells_resize_
- f_status_t f_cells_resize(const f_number_unsigned_t length, f_cells_t *cells) {
+ f_status_t f_cells_resize(const f_number_unsigned_t length, f_cells_t * const cells) {
#ifndef _di_level_0_parameter_checking_
if (!cells) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_cells_resize_
#ifndef _di_f_cellss_adjust_
- f_status_t f_cellss_adjust(const f_number_unsigned_t length, f_cellss_t *cellss) {
+ f_status_t f_cellss_adjust(const f_number_unsigned_t length, f_cellss_t * const cellss) {
#ifndef _di_level_0_parameter_checking_
if (!cellss) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_cellss_adjust_
#ifndef _di_f_cellss_append_
- f_status_t f_cellss_append(const f_cells_t source, f_cellss_t *destination) {
+ f_status_t f_cellss_append(const f_cells_t source, f_cellss_t * const destination) {
#ifndef _di_level_0_parameter_checking_
if (!destination) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_cellss_append_
#ifndef _di_f_cellss_append_all_
- f_status_t f_cellss_append_all(const f_cellss_t source, f_cellss_t *destination) {
+ f_status_t f_cellss_append_all(const f_cellss_t source, f_cellss_t * const destination) {
#ifndef _di_level_0_parameter_checking_
if (!destination) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_cellss_append_all_
#ifndef _di_f_cellss_decimate_by_
- f_status_t f_cellss_decimate_by(const f_number_unsigned_t amount, f_cellss_t *cellss) {
+ f_status_t f_cellss_decimate_by(const f_number_unsigned_t amount, f_cellss_t * const cellss) {
#ifndef _di_level_0_parameter_checking_
if (!cellss) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_cellss_decimate_by_
#ifndef _di_f_cellss_decrease_by_
- f_status_t f_cellss_decrease_by(const f_number_unsigned_t amount, f_cellss_t *cellss) {
+ f_status_t f_cellss_decrease_by(const f_number_unsigned_t amount, f_cellss_t * const cellss) {
#ifndef _di_level_0_parameter_checking_
if (!cellss) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_cellss_decrease_by_
#ifndef _di_f_cellss_increase_
- f_status_t f_cellss_increase(const f_number_unsigned_t step, f_cellss_t *cellss) {
+ f_status_t f_cellss_increase(const f_number_unsigned_t step, f_cellss_t * const cellss) {
#ifndef _di_level_0_parameter_checking_
if (!cellss) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_cellss_increase_
#ifndef _di_f_cellss_increase_by_
- f_status_t f_cellss_increase_by(const f_number_unsigned_t amount, f_cellss_t *cellss) {
+ f_status_t f_cellss_increase_by(const f_number_unsigned_t amount, f_cellss_t * const cellss) {
#ifndef _di_level_0_parameter_checking_
if (!cellss) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_cellss_increase_by_
#ifndef _di_f_cellss_resize_
- f_status_t f_cellss_resize(const f_number_unsigned_t length, f_cellss_t *cellss) {
+ f_status_t f_cellss_resize(const f_number_unsigned_t length, f_cellss_t * const cellss) {
#ifndef _di_level_0_parameter_checking_
if (!cellss) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
* Errors (with error bit) from: f_memory_adjust().
*/
#ifndef _di_f_cells_adjust_
- extern f_status_t f_cells_adjust(const f_number_unsigned_t length, f_cells_t *cells);
+ extern f_status_t f_cells_adjust(const f_number_unsigned_t length, f_cells_t * const cells);
#endif // _di_f_cells_adjust_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_cells_append_
- extern f_status_t f_cells_append(const f_cell_t source, f_cells_t *destination);
+ extern f_status_t f_cells_append(const f_cell_t source, f_cells_t * const destination);
#endif // _di_f_cells_append_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_cells_append_all_
- extern f_status_t f_cells_append_all(const f_cells_t source, f_cells_t *destination);
+ extern f_status_t f_cells_append_all(const f_cells_t source, f_cells_t * const destination);
#endif // _di_f_cells_append_all_
/**
* Errors (with error bit) from: f_memory_adjust().
*/
#ifndef _di_f_cells_decimate_by_
- extern f_status_t f_cells_decimate_by(const f_number_unsigned_t amount, f_cells_t *cells);
+ extern f_status_t f_cells_decimate_by(const f_number_unsigned_t amount, f_cells_t * const cells);
#endif // _di_f_cells_decimate_by_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_cells_decrease_by_
- extern f_status_t f_cells_decrease_by(const f_number_unsigned_t amount, f_cells_t *cells);
+ extern f_status_t f_cells_decrease_by(const f_number_unsigned_t amount, f_cells_t * const cells);
#endif // _di_f_cells_decrease_by_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_cells_increase_
- extern f_status_t f_cells_increase(const f_number_unsigned_t step, f_cells_t *cells);
+ extern f_status_t f_cells_increase(const f_number_unsigned_t step, f_cells_t * const cells);
#endif // _di_f_cells_increase_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_cells_increase_by_
- extern f_status_t f_cells_increase_by(const f_number_unsigned_t amount, f_cells_t *cells);
+ extern f_status_t f_cells_increase_by(const f_number_unsigned_t amount, f_cells_t * const cells);
#endif // _di_f_cells_increase_by_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_cells_resize_
- extern f_status_t f_cells_resize(const f_number_unsigned_t length, f_cells_t *cells);
+ extern f_status_t f_cells_resize(const f_number_unsigned_t length, f_cells_t * const cells);
#endif // _di_f_cells_resize_
/**
* Errors (with error bit) from: f_memory_destroy().
*/
#ifndef _di_f_cellss_adjust_
- extern f_status_t f_cellss_adjust(const f_number_unsigned_t length, f_cellss_t *cellss);
+ extern f_status_t f_cellss_adjust(const f_number_unsigned_t length, f_cellss_t * const cellss);
#endif // _di_f_cellss_adjust_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_cellss_append_
- extern f_status_t f_cellss_append(const f_cells_t source, f_cellss_t *destination);
+ extern f_status_t f_cellss_append(const f_cells_t source, f_cellss_t * const destination);
#endif // _di_f_cellss_append_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_cellss_append_all_
- extern f_status_t f_cellss_append_all(const f_cellss_t source, f_cellss_t *destination);
+ extern f_status_t f_cellss_append_all(const f_cellss_t source, f_cellss_t * const destination);
#endif // _di_f_cellss_append_all_
/**
* Errors (with error bit) from: f_memory_destroy().
*/
#ifndef _di_f_cellss_decimate_by_
- extern f_status_t f_cellss_decimate_by(const f_number_unsigned_t amount, f_cellss_t *cellss);
+ extern f_status_t f_cellss_decimate_by(const f_number_unsigned_t amount, f_cellss_t * const cellss);
#endif // _di_f_cellss_decimate_by_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_cellss_decrease_by_
- extern f_status_t f_cellss_decrease_by(const f_number_unsigned_t amount, f_cellss_t *cellss);
+ extern f_status_t f_cellss_decrease_by(const f_number_unsigned_t amount, f_cellss_t * const cellss);
#endif // _di_f_cellss_decrease_by_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_cellss_increase_
- extern f_status_t f_cellss_increase(const f_number_unsigned_t step, f_cellss_t *cellss);
+ extern f_status_t f_cellss_increase(const f_number_unsigned_t step, f_cellss_t * const cellss);
#endif // _di_f_cellss_increase_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_cellss_increase_by_
- extern f_status_t f_cellss_increase_by(const f_number_unsigned_t amount, f_cellss_t *cellss);
+ extern f_status_t f_cellss_increase_by(const f_number_unsigned_t amount, f_cellss_t * const cellss);
#endif // _di_f_cellss_increase_by_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_cellss_resize_
- extern f_status_t f_cellss_resize(const f_number_unsigned_t length, f_cellss_t *cellss);
+ extern f_status_t f_cellss_resize(const f_number_unsigned_t length, f_cellss_t * const cellss);
#endif // _di_f_cellss_resize_
#ifdef __cplusplus
#endif
#ifndef _di_f_files_adjust_
- f_status_t f_files_adjust(const f_number_unsigned_t length, f_files_t *files) {
+ f_status_t f_files_adjust(const f_number_unsigned_t length, f_files_t * const files) {
#ifndef _di_level_0_parameter_checking_
if (!files) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_files_adjust_
#ifndef _di_f_files_append_
- f_status_t f_files_append(const f_file_t source, f_files_t *destination) {
+ f_status_t f_files_append(const f_file_t source, f_files_t * const destination) {
#ifndef _di_level_0_parameter_checking_
if (!destination) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_files_append_
#ifndef _di_f_files_append_all_
- f_status_t f_files_append_all(const f_files_t source, f_files_t *destination) {
+ f_status_t f_files_append_all(const f_files_t source, f_files_t * const destination) {
#ifndef _di_level_0_parameter_checking_
if (!destination) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_files_append_all_
#ifndef _di_f_files_decimate_by_
- f_status_t f_files_decimate_by(const f_number_unsigned_t amount, f_files_t *files) {
+ f_status_t f_files_decimate_by(const f_number_unsigned_t amount, f_files_t * const files) {
#ifndef _di_level_0_parameter_checking_
if (!files) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_files_decimate_by_
#ifndef _di_f_files_decrease_by_
- f_status_t f_files_decrease_by(const f_number_unsigned_t amount, f_files_t *files) {
+ f_status_t f_files_decrease_by(const f_number_unsigned_t amount, f_files_t * const files) {
#ifndef _di_level_0_parameter_checking_
if (!files) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_files_decrease_by_
#ifndef _di_f_files_increase_
- f_status_t f_files_increase(const f_number_unsigned_t step, f_files_t *files) {
+ f_status_t f_files_increase(const f_number_unsigned_t step, f_files_t * const files) {
#ifndef _di_level_0_parameter_checking_
if (!files) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_files_increase_
#ifndef _di_f_files_increase_by_
- f_status_t f_files_increase_by(const f_number_unsigned_t amount, f_files_t *files) {
+ f_status_t f_files_increase_by(const f_number_unsigned_t amount, f_files_t * const files) {
#ifndef _di_level_0_parameter_checking_
if (!files) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_files_increase_by_
#ifndef _di_f_files_resize_
- f_status_t f_files_resize(const f_number_unsigned_t length, f_files_t *files) {
+ f_status_t f_files_resize(const f_number_unsigned_t length, f_files_t * const files) {
#ifndef _di_level_0_parameter_checking_
if (!files) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_files_resize_
#ifndef _di_f_filess_adjust_
- f_status_t f_filess_adjust(const f_number_unsigned_t length, f_filess_t *filess) {
+ f_status_t f_filess_adjust(const f_number_unsigned_t length, f_filess_t * const filess) {
#ifndef _di_level_0_parameter_checking_
if (!filess) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_filess_adjust_
#ifndef _di_f_filess_append_
- f_status_t f_filess_append(const f_files_t source, f_filess_t *destination) {
+ f_status_t f_filess_append(const f_files_t source, f_filess_t * const destination) {
#ifndef _di_level_0_parameter_checking_
if (!destination) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_filess_append_
#ifndef _di_f_filess_append_all_
- f_status_t f_filess_append_all(const f_filess_t source, f_filess_t *destination) {
+ f_status_t f_filess_append_all(const f_filess_t source, f_filess_t * const destination) {
#ifndef _di_level_0_parameter_checking_
if (!destination) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_filess_append_all_
#ifndef _di_f_filess_decimate_by_
- f_status_t f_filess_decimate_by(const f_number_unsigned_t amount, f_filess_t *filess) {
+ f_status_t f_filess_decimate_by(const f_number_unsigned_t amount, f_filess_t * const filess) {
#ifndef _di_level_0_parameter_checking_
if (!filess) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_filess_decimate_by_
#ifndef _di_f_filess_decrease_by_
- f_status_t f_filess_decrease_by(const f_number_unsigned_t amount, f_filess_t *filess) {
+ f_status_t f_filess_decrease_by(const f_number_unsigned_t amount, f_filess_t * const filess) {
#ifndef _di_level_0_parameter_checking_
if (!filess) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_filess_decrease_by_
#ifndef _di_f_filess_increase_
- f_status_t f_filess_increase(const f_number_unsigned_t step, f_filess_t *filess) {
+ f_status_t f_filess_increase(const f_number_unsigned_t step, f_filess_t * const filess) {
#ifndef _di_level_0_parameter_checking_
if (!filess) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_filess_increase_
#ifndef _di_f_filess_increase_by_
- f_status_t f_filess_increase_by(const f_number_unsigned_t amount, f_filess_t *filess) {
+ f_status_t f_filess_increase_by(const f_number_unsigned_t amount, f_filess_t * const filess) {
#ifndef _di_level_0_parameter_checking_
if (!filess) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_filess_increase_by_
#ifndef _di_f_filess_resize_
- f_status_t f_filess_resize(const f_number_unsigned_t length, f_filess_t *filess) {
+ f_status_t f_filess_resize(const f_number_unsigned_t length, f_filess_t * const filess) {
#ifndef _di_level_0_parameter_checking_
if (!filess) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
* Errors (with error bit) from: f_memory_adjust().
*/
#ifndef _di_f_files_adjust_
- extern f_status_t f_files_adjust(const f_number_unsigned_t length, f_files_t *files);
+ extern f_status_t f_files_adjust(const f_number_unsigned_t length, f_files_t * const files);
#endif // _di_f_files_adjust_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_files_append_
- extern f_status_t f_files_append(const f_file_t source, f_files_t *destination);
+ extern f_status_t f_files_append(const f_file_t source, f_files_t * const destination);
#endif // _di_f_files_append_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_files_append_all_
- extern f_status_t f_files_append_all(const f_files_t source, f_files_t *destination);
+ extern f_status_t f_files_append_all(const f_files_t source, f_files_t * const destination);
#endif // _di_f_files_append_all_
/**
* Errors (with error bit) from: f_memory_adjust().
*/
#ifndef _di_f_files_decimate_by_
- extern f_status_t f_files_decimate_by(const f_number_unsigned_t amount, f_files_t *files);
+ extern f_status_t f_files_decimate_by(const f_number_unsigned_t amount, f_files_t * const files);
#endif // _di_f_files_decimate_by_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_files_decrease_by_
- extern f_status_t f_files_decrease_by(const f_number_unsigned_t amount, f_files_t *files);
+ extern f_status_t f_files_decrease_by(const f_number_unsigned_t amount, f_files_t * const files);
#endif // _di_f_files_decrease_by_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_files_increase_
- extern f_status_t f_files_increase(const f_number_unsigned_t step, f_files_t *files);
+ extern f_status_t f_files_increase(const f_number_unsigned_t step, f_files_t * const files);
#endif // _di_f_files_increase_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_files_increase_by_
- extern f_status_t f_files_increase_by(const f_number_unsigned_t amount, f_files_t *files);
+ extern f_status_t f_files_increase_by(const f_number_unsigned_t amount, f_files_t * const files);
#endif // _di_f_files_increase_by_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_files_resize_
- extern f_status_t f_files_resize(const f_number_unsigned_t length, f_files_t *files);
+ extern f_status_t f_files_resize(const f_number_unsigned_t length, f_files_t * const files);
#endif // _di_f_files_resize_
/**
* Errors (with error bit) from: f_memory_destroy().
*/
#ifndef _di_f_filess_adjust_
- extern f_status_t f_filess_adjust(const f_number_unsigned_t length, f_filess_t *filess);
+ extern f_status_t f_filess_adjust(const f_number_unsigned_t length, f_filess_t * const filess);
#endif // _di_f_filess_adjust_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_filess_append_
- extern f_status_t f_filess_append(const f_files_t source, f_filess_t *destination);
+ extern f_status_t f_filess_append(const f_files_t source, f_filess_t * const destination);
#endif // _di_f_filess_append_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_filess_append_all_
- extern f_status_t f_filess_append_all(const f_filess_t source, f_filess_t *destination);
+ extern f_status_t f_filess_append_all(const f_filess_t source, f_filess_t * const destination);
#endif // _di_f_filess_append_all_
/**
* Errors (with error bit) from: f_memory_destroy().
*/
#ifndef _di_f_filess_decimate_by_
- extern f_status_t f_filess_decimate_by(const f_number_unsigned_t amount, f_filess_t *filess);
+ extern f_status_t f_filess_decimate_by(const f_number_unsigned_t amount, f_filess_t * const filess);
#endif // _di_f_filess_decimate_by_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_filess_decrease_by_
- extern f_status_t f_filess_decrease_by(const f_number_unsigned_t amount, f_filess_t *filess);
+ extern f_status_t f_filess_decrease_by(const f_number_unsigned_t amount, f_filess_t * const filess);
#endif // _di_f_filess_decrease_by_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_filess_increase_
- extern f_status_t f_filess_increase(const f_number_unsigned_t step, f_filess_t *filess);
+ extern f_status_t f_filess_increase(const f_number_unsigned_t step, f_filess_t * const filess);
#endif // _di_f_filess_increase_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_filess_increase_by_
- extern f_status_t f_filess_increase_by(const f_number_unsigned_t amount, f_filess_t *filess);
+ extern f_status_t f_filess_increase_by(const f_number_unsigned_t amount, f_filess_t * const filess);
#endif // _di_f_filess_increase_by_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_filess_resize_
- extern f_status_t f_filess_resize(const f_number_unsigned_t length, f_filess_t *filess);
+ extern f_status_t f_filess_resize(const f_number_unsigned_t length, f_filess_t * const filess);
#endif // _di_f_filess_resize_
#ifdef __cplusplus
#endif
#ifndef _di_f_fll_ids_adjust_
- f_status_t f_fll_ids_adjust(const f_number_unsigned_t length, f_fll_ids_t *ids) {
+ f_status_t f_fll_ids_adjust(const f_number_unsigned_t length, f_fll_ids_t * const ids) {
#ifndef _di_level_0_parameter_checking_
if (!ids) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_fll_ids_adjust_
#ifndef _di_f_fll_ids_append_
- f_status_t f_fll_ids_append(const f_fll_id_t source, f_fll_ids_t *destination) {
+ f_status_t f_fll_ids_append(const f_fll_id_t source, f_fll_ids_t * const destination) {
#ifndef _di_level_0_parameter_checking_
if (!destination) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_fll_ids_append_
#ifndef _di_f_fll_ids_append_all_
- f_status_t f_fll_ids_append_all(const f_fll_ids_t source, f_fll_ids_t *destination) {
+ f_status_t f_fll_ids_append_all(const f_fll_ids_t source, f_fll_ids_t * const destination) {
#ifndef _di_level_0_parameter_checking_
if (!destination) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_fll_ids_append_all_
#ifndef _di_f_fll_ids_decimate_by_
- f_status_t f_fll_ids_decimate_by(const f_number_unsigned_t amount, f_fll_ids_t *ids) {
+ f_status_t f_fll_ids_decimate_by(const f_number_unsigned_t amount, f_fll_ids_t * const ids) {
#ifndef _di_level_0_parameter_checking_
if (!ids) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_fll_ids_decimate_by_
#ifndef _di_f_fll_ids_decrease_by_
- f_status_t f_fll_ids_decrease_by(const f_number_unsigned_t amount, f_fll_ids_t *ids) {
+ f_status_t f_fll_ids_decrease_by(const f_number_unsigned_t amount, f_fll_ids_t * const ids) {
#ifndef _di_level_0_parameter_checking_
if (!ids) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_fll_ids_decrease_by_
#ifndef _di_f_fll_ids_increase_
- f_status_t f_fll_ids_increase(const f_number_unsigned_t step, f_fll_ids_t *ids) {
+ f_status_t f_fll_ids_increase(const f_number_unsigned_t step, f_fll_ids_t * const ids) {
#ifndef _di_level_0_parameter_checking_
if (!ids) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_fll_ids_increase_
#ifndef _di_f_fll_ids_increase_by_
- f_status_t f_fll_ids_increase_by(const f_number_unsigned_t amount, f_fll_ids_t *ids) {
+ f_status_t f_fll_ids_increase_by(const f_number_unsigned_t amount, f_fll_ids_t * const ids) {
#ifndef _di_level_0_parameter_checking_
if (!ids) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_fll_ids_increase_by_
#ifndef _di_f_fll_ids_resize_
- f_status_t f_fll_ids_resize(const f_number_unsigned_t length, f_fll_ids_t *ids) {
+ f_status_t f_fll_ids_resize(const f_number_unsigned_t length, f_fll_ids_t * const ids) {
#ifndef _di_level_0_parameter_checking_
if (!ids) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_fll_ids_resize_
#ifndef _di_f_fll_idss_adjust_
- f_status_t f_fll_idss_adjust(const f_number_unsigned_t length, f_fll_idss_t *idss) {
+ f_status_t f_fll_idss_adjust(const f_number_unsigned_t length, f_fll_idss_t * const idss) {
#ifndef _di_level_0_parameter_checking_
if (!idss) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_fll_idss_adjust_
#ifndef _di_f_fll_idss_append_
- f_status_t f_fll_idss_append(const f_fll_ids_t source, f_fll_idss_t *destination) {
+ f_status_t f_fll_idss_append(const f_fll_ids_t source, f_fll_idss_t * const destination) {
#ifndef _di_level_0_parameter_checking_
if (!destination) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_fll_idss_append_
#ifndef _di_f_fll_idss_append_all_
- f_status_t f_fll_idss_append_all(const f_fll_idss_t source, f_fll_idss_t *destination) {
+ f_status_t f_fll_idss_append_all(const f_fll_idss_t source, f_fll_idss_t * const destination) {
#ifndef _di_level_0_parameter_checking_
if (!destination) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_fll_idss_append_all_
#ifndef _di_f_fll_idss_decimate_by_
- f_status_t f_fll_idss_decimate_by(const f_number_unsigned_t amount, f_fll_idss_t *idss) {
+ f_status_t f_fll_idss_decimate_by(const f_number_unsigned_t amount, f_fll_idss_t * const idss) {
#ifndef _di_level_0_parameter_checking_
if (!idss) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_fll_idss_decimate_by_
#ifndef _di_f_fll_idss_decrease_by_
- f_status_t f_fll_idss_decrease_by(const f_number_unsigned_t amount, f_fll_idss_t *idss) {
+ f_status_t f_fll_idss_decrease_by(const f_number_unsigned_t amount, f_fll_idss_t * const idss) {
#ifndef _di_level_0_parameter_checking_
if (!idss) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_fll_idss_decrease_by_
#ifndef _di_f_fll_idss_increase_
- f_status_t f_fll_idss_increase(const f_number_unsigned_t step, f_fll_idss_t *idss) {
+ f_status_t f_fll_idss_increase(const f_number_unsigned_t step, f_fll_idss_t * const idss) {
#ifndef _di_level_0_parameter_checking_
if (!idss) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_fll_idss_increase_
#ifndef _di_f_fll_idss_increase_by_
- f_status_t f_fll_idss_increase_by(const f_number_unsigned_t amount, f_fll_idss_t *idss) {
+ f_status_t f_fll_idss_increase_by(const f_number_unsigned_t amount, f_fll_idss_t * const idss) {
#ifndef _di_level_0_parameter_checking_
if (!idss) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_fll_idss_increase_by_
#ifndef _di_f_fll_idss_resize_
- f_status_t f_fll_idss_resize(const f_number_unsigned_t length, f_fll_idss_t *idss) {
+ f_status_t f_fll_idss_resize(const f_number_unsigned_t length, f_fll_idss_t * const idss) {
#ifndef _di_level_0_parameter_checking_
if (!idss) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
* Errors (with error bit) from: f_memory_adjust().
*/
#ifndef _di_f_fll_ids_adjust_
- extern f_status_t f_fll_ids_adjust(const f_number_unsigned_t length, f_fll_ids_t *ids);
+ extern f_status_t f_fll_ids_adjust(const f_number_unsigned_t length, f_fll_ids_t * const ids);
#endif // _di_f_fll_ids_adjust_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_fll_ids_append_
- extern f_status_t f_fll_ids_append(const f_fll_id_t source, f_fll_ids_t *destination);
+ extern f_status_t f_fll_ids_append(const f_fll_id_t source, f_fll_ids_t * const destination);
#endif // _di_f_fll_ids_append_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_fll_ids_append_all_
- extern f_status_t f_fll_ids_append_all(const f_fll_ids_t source, f_fll_ids_t *destination);
+ extern f_status_t f_fll_ids_append_all(const f_fll_ids_t source, f_fll_ids_t * const destination);
#endif // _di_f_fll_ids_append_all_
/**
* Errors (with error bit) from: f_memory_adjust().
*/
#ifndef _di_f_fll_ids_decimate_by_
- extern f_status_t f_fll_ids_decimate_by(const f_number_unsigned_t amount, f_fll_ids_t *ids);
+ extern f_status_t f_fll_ids_decimate_by(const f_number_unsigned_t amount, f_fll_ids_t * const ids);
#endif // _di_f_fll_ids_decimate_by_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_fll_ids_decrease_by_
- extern f_status_t f_fll_ids_decrease_by(const f_number_unsigned_t amount, f_fll_ids_t *ids);
+ extern f_status_t f_fll_ids_decrease_by(const f_number_unsigned_t amount, f_fll_ids_t * const ids);
#endif // _di_f_fll_ids_decrease_by_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_fll_ids_increase_
- extern f_status_t f_fll_ids_increase(const f_number_unsigned_t step, f_fll_ids_t *ids);
+ extern f_status_t f_fll_ids_increase(const f_number_unsigned_t step, f_fll_ids_t * const ids);
#endif // _di_f_fll_ids_increase_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_fll_ids_increase_by_
- extern f_status_t f_fll_ids_increase_by(const f_number_unsigned_t amount, f_fll_ids_t *ids);
+ extern f_status_t f_fll_ids_increase_by(const f_number_unsigned_t amount, f_fll_ids_t * const ids);
#endif // _di_f_fll_ids_increase_by_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_fll_ids_resize_
- extern f_status_t f_fll_ids_resize(const f_number_unsigned_t length, f_fll_ids_t *ids);
+ extern f_status_t f_fll_ids_resize(const f_number_unsigned_t length, f_fll_ids_t * const ids);
#endif // _di_f_fll_ids_resize_
/**
* Errors (with error bit) from: f_memory_destroy().
*/
#ifndef _di_f_fll_idss_adjust_
- extern f_status_t f_fll_idss_adjust(const f_number_unsigned_t length, f_fll_idss_t *idss);
+ extern f_status_t f_fll_idss_adjust(const f_number_unsigned_t length, f_fll_idss_t * const idss);
#endif // _di_f_fll_idss_adjust_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_fll_idss_append_
- extern f_status_t f_fll_idss_append(const f_fll_ids_t source, f_fll_idss_t *destination);
+ extern f_status_t f_fll_idss_append(const f_fll_ids_t source, f_fll_idss_t * const destination);
#endif // _di_f_fll_idss_append_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_fll_idss_append_all_
- extern f_status_t f_fll_idss_append_all(const f_fll_idss_t source, f_fll_idss_t *destination);
+ extern f_status_t f_fll_idss_append_all(const f_fll_idss_t source, f_fll_idss_t * const destination);
#endif // _di_f_fll_idss_append_all_
/**
* Errors (with error bit) from: f_memory_destroy().
*/
#ifndef _di_f_fll_idss_decimate_by_
- extern f_status_t f_fll_idss_decimate_by(const f_number_unsigned_t amount, f_fll_idss_t *idss);
+ extern f_status_t f_fll_idss_decimate_by(const f_number_unsigned_t amount, f_fll_idss_t * const idss);
#endif // _di_f_fll_idss_decimate_by_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_fll_idss_decrease_by_
- extern f_status_t f_fll_idss_decrease_by(const f_number_unsigned_t amount, f_fll_idss_t *idss);
+ extern f_status_t f_fll_idss_decrease_by(const f_number_unsigned_t amount, f_fll_idss_t * const idss);
#endif // _di_f_fll_idss_decrease_by_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_fll_idss_increase_
- extern f_status_t f_fll_idss_increase(const f_number_unsigned_t step, f_fll_idss_t *idss);
+ extern f_status_t f_fll_idss_increase(const f_number_unsigned_t step, f_fll_idss_t * const idss);
#endif // _di_f_fll_idss_increase_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_fll_idss_increase_by_
- extern f_status_t f_fll_idss_increase_by(const f_number_unsigned_t amount, f_fll_idss_t *idss);
+ extern f_status_t f_fll_idss_increase_by(const f_number_unsigned_t amount, f_fll_idss_t * const idss);
#endif // _di_f_fll_idss_increase_by_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_fll_idss_resize_
- extern f_status_t f_fll_idss_resize(const f_number_unsigned_t length, f_fll_idss_t *idss);
+ extern f_status_t f_fll_idss_resize(const f_number_unsigned_t length, f_fll_idss_t * const idss);
#endif // _di_f_fll_idss_resize_
#ifdef __cplusplus
#endif
#ifndef _di_f_int128s_adjust_
- f_status_t f_int128s_adjust(const f_number_unsigned_t length, f_int128s_t *int128s) {
+ f_status_t f_int128s_adjust(const f_number_unsigned_t length, f_int128s_t * const int128s) {
#ifndef _di_level_0_parameter_checking_
if (!int128s) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_int128s_adjust_
#ifndef _di_f_int128s_append_
- f_status_t f_int128s_append(const int128_t source, f_int128s_t *destination) {
+ f_status_t f_int128s_append(const int128_t source, f_int128s_t * const destination) {
#ifndef _di_level_0_parameter_checking_
if (!destination) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_int128s_append_
#ifndef _di_f_int128s_append_all_
- f_status_t f_int128s_append_all(const f_int128s_t source, f_int128s_t *destination) {
+ f_status_t f_int128s_append_all(const f_int128s_t source, f_int128s_t * const destination) {
#ifndef _di_level_0_parameter_checking_
if (!destination) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_int128s_append_all_
#ifndef _di_f_int128s_decimate_by_
- f_status_t f_int128s_decimate_by(const f_number_unsigned_t amount, f_int128s_t *int128s) {
+ f_status_t f_int128s_decimate_by(const f_number_unsigned_t amount, f_int128s_t * const int128s) {
#ifndef _di_level_0_parameter_checking_
if (!int128s) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_int128s_decimate_by_
#ifndef _di_f_int128s_decrease_by_
- f_status_t f_int128s_decrease_by(const f_number_unsigned_t amount, f_int128s_t *int128s) {
+ f_status_t f_int128s_decrease_by(const f_number_unsigned_t amount, f_int128s_t * const int128s) {
#ifndef _di_level_0_parameter_checking_
if (!int128s) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_int128s_decrease_by_
#ifndef _di_f_int128s_increase_
- f_status_t f_int128s_increase(const f_number_unsigned_t step, f_int128s_t *int128s) {
+ f_status_t f_int128s_increase(const f_number_unsigned_t step, f_int128s_t * const int128s) {
#ifndef _di_level_0_parameter_checking_
if (!int128s) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_int128s_increase_
#ifndef _di_f_int128s_increase_by_
- f_status_t f_int128s_increase_by(const f_number_unsigned_t amount, f_int128s_t *int128s) {
+ f_status_t f_int128s_increase_by(const f_number_unsigned_t amount, f_int128s_t * const int128s) {
#ifndef _di_level_0_parameter_checking_
if (!int128s) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_int128s_increase_by_
#ifndef _di_f_int128s_resize_
- f_status_t f_int128s_resize(const f_number_unsigned_t length, f_int128s_t *int128s) {
+ f_status_t f_int128s_resize(const f_number_unsigned_t length, f_int128s_t * const int128s) {
#ifndef _di_level_0_parameter_checking_
if (!int128s) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_int128s_resize_
#ifndef _di_f_int128ss_adjust_
- f_status_t f_int128ss_adjust(const f_number_unsigned_t length, f_int128ss_t *int128ss) {
+ f_status_t f_int128ss_adjust(const f_number_unsigned_t length, f_int128ss_t * const int128ss) {
#ifndef _di_level_0_parameter_checking_
if (!int128ss) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_int128ss_adjust_
#ifndef _di_f_int128ss_append_
- f_status_t f_int128ss_append(const f_int128s_t source, f_int128ss_t *destination) {
+ f_status_t f_int128ss_append(const f_int128s_t source, f_int128ss_t * const destination) {
#ifndef _di_level_0_parameter_checking_
if (!destination) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_int128ss_append_
#ifndef _di_f_int128ss_append_all_
- f_status_t f_int128ss_append_all(const f_int128ss_t source, f_int128ss_t *destination) {
+ f_status_t f_int128ss_append_all(const f_int128ss_t source, f_int128ss_t * const destination) {
#ifndef _di_level_0_parameter_checking_
if (!destination) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_int128ss_append_all_
#ifndef _di_f_int128ss_decimate_by_
- f_status_t f_int128ss_decimate_by(const f_number_unsigned_t amount, f_int128ss_t *int128ss) {
+ f_status_t f_int128ss_decimate_by(const f_number_unsigned_t amount, f_int128ss_t * const int128ss) {
#ifndef _di_level_0_parameter_checking_
if (!int128ss) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_int128ss_decimate_by_
#ifndef _di_f_int128ss_decrease_by_
- f_status_t f_int128ss_decrease_by(const f_number_unsigned_t amount, f_int128ss_t *int128ss) {
+ f_status_t f_int128ss_decrease_by(const f_number_unsigned_t amount, f_int128ss_t * const int128ss) {
#ifndef _di_level_0_parameter_checking_
if (!int128ss) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_int128ss_decrease_by_
#ifndef _di_f_int128ss_increase_
- f_status_t f_int128ss_increase(const f_number_unsigned_t step, f_int128ss_t *int128ss) {
+ f_status_t f_int128ss_increase(const f_number_unsigned_t step, f_int128ss_t * const int128ss) {
#ifndef _di_level_0_parameter_checking_
if (!int128ss) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_int128ss_increase_
#ifndef _di_f_int128ss_increase_by_
- f_status_t f_int128ss_increase_by(const f_number_unsigned_t amount, f_int128ss_t *int128ss) {
+ f_status_t f_int128ss_increase_by(const f_number_unsigned_t amount, f_int128ss_t * const int128ss) {
#ifndef _di_level_0_parameter_checking_
if (!int128ss) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_int128ss_increase_by_
#ifndef _di_f_int128ss_resize_
- f_status_t f_int128ss_resize(const f_number_unsigned_t length, f_int128ss_t *int128ss) {
+ f_status_t f_int128ss_resize(const f_number_unsigned_t length, f_int128ss_t * const int128ss) {
#ifndef _di_level_0_parameter_checking_
if (!int128ss) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
* Errors (with error bit) from: f_memory_adjust().
*/
#ifndef _di_f_int128s_adjust_
- extern f_status_t f_int128s_adjust(const f_number_unsigned_t length, f_int128s_t *int128s);
+ extern f_status_t f_int128s_adjust(const f_number_unsigned_t length, f_int128s_t * const int128s);
#endif // _di_f_int128s_adjust_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_int128s_append_
- extern f_status_t f_int128s_append(const int128_t source, f_int128s_t *destination);
+ extern f_status_t f_int128s_append(const int128_t source, f_int128s_t * const destination);
#endif // _di_f_int128s_append_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_int128s_append_all_
- extern f_status_t f_int128s_append_all(const f_int128s_t source, f_int128s_t *destination);
+ extern f_status_t f_int128s_append_all(const f_int128s_t source, f_int128s_t * const destination);
#endif // _di_f_int128s_append_all_
/**
* Errors (with error bit) from: f_memory_adjust().
*/
#ifndef _di_f_int128s_decimate_by_
- extern f_status_t f_int128s_decimate_by(const f_number_unsigned_t amount, f_int128s_t *int128s);
+ extern f_status_t f_int128s_decimate_by(const f_number_unsigned_t amount, f_int128s_t * const int128s);
#endif // _di_f_int128s_decimate_by_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_int128s_decrease_by_
- extern f_status_t f_int128s_decrease_by(const f_number_unsigned_t amount, f_int128s_t *int128s);
+ extern f_status_t f_int128s_decrease_by(const f_number_unsigned_t amount, f_int128s_t * const int128s);
#endif // _di_f_int128s_decrease_by_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_int128s_increase_
- extern f_status_t f_int128s_increase(const f_number_unsigned_t step, f_int128s_t *int128s);
+ extern f_status_t f_int128s_increase(const f_number_unsigned_t step, f_int128s_t * const int128s);
#endif // _di_f_int128s_increase_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_int128s_increase_by_
- extern f_status_t f_int128s_increase_by(const f_number_unsigned_t amount, f_int128s_t *int128s);
+ extern f_status_t f_int128s_increase_by(const f_number_unsigned_t amount, f_int128s_t * const int128s);
#endif // _di_f_int128s_increase_by_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_int128s_resize_
- extern f_status_t f_int128s_resize(const f_number_unsigned_t length, f_int128s_t *int128s);
+ extern f_status_t f_int128s_resize(const f_number_unsigned_t length, f_int128s_t * const int128s);
#endif // _di_f_int128s_resize_
/**
* Errors (with error bit) from: f_memory_destroy().
*/
#ifndef _di_f_int128ss_adjust_
- extern f_status_t f_int128ss_adjust(const f_number_unsigned_t length, f_int128ss_t *int128ss);
+ extern f_status_t f_int128ss_adjust(const f_number_unsigned_t length, f_int128ss_t * const int128ss);
#endif // _di_f_int128ss_adjust_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_int128ss_append_
- extern f_status_t f_int128ss_append(const f_int128s_t source, f_int128ss_t *destination);
+ extern f_status_t f_int128ss_append(const f_int128s_t source, f_int128ss_t * const destination);
#endif // _di_f_int128ss_append_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_int128ss_append_all_
- extern f_status_t f_int128ss_append_all(const f_int128ss_t source, f_int128ss_t *destination);
+ extern f_status_t f_int128ss_append_all(const f_int128ss_t source, f_int128ss_t * const destination);
#endif // _di_f_int128ss_append_all_
/**
* Errors (with error bit) from: f_memory_destroy().
*/
#ifndef _di_f_int128ss_decimate_by_
- extern f_status_t f_int128ss_decimate_by(const f_number_unsigned_t amount, f_int128ss_t *int128ss);
+ extern f_status_t f_int128ss_decimate_by(const f_number_unsigned_t amount, f_int128ss_t * const int128ss);
#endif // _di_f_int128ss_decimate_by_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_int128ss_decrease_by_
- extern f_status_t f_int128ss_decrease_by(const f_number_unsigned_t amount, f_int128ss_t *int128ss);
+ extern f_status_t f_int128ss_decrease_by(const f_number_unsigned_t amount, f_int128ss_t * const int128ss);
#endif // _di_f_int128ss_decrease_by_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_int128ss_increase_
- extern f_status_t f_int128ss_increase(const f_number_unsigned_t step, f_int128ss_t *int128ss);
+ extern f_status_t f_int128ss_increase(const f_number_unsigned_t step, f_int128ss_t * const int128ss);
#endif // _di_f_int128ss_increase_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_int128ss_increase_by_
- extern f_status_t f_int128ss_increase_by(const f_number_unsigned_t amount, f_int128ss_t *int128ss);
+ extern f_status_t f_int128ss_increase_by(const f_number_unsigned_t amount, f_int128ss_t * const int128ss);
#endif // _di_f_int128ss_increase_by_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_int128ss_resize_
- extern f_status_t f_int128ss_resize(const f_number_unsigned_t length, f_int128ss_t *int128ss);
+ extern f_status_t f_int128ss_resize(const f_number_unsigned_t length, f_int128ss_t * const int128ss);
#endif // _di_f_int128ss_resize_
#ifdef __cplusplus
#endif
#ifndef _di_f_int16s_adjust_
- f_status_t f_int16s_adjust(const f_number_unsigned_t length, f_int16s_t *int16s) {
+ f_status_t f_int16s_adjust(const f_number_unsigned_t length, f_int16s_t * const int16s) {
#ifndef _di_level_0_parameter_checking_
if (!int16s) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_int16s_adjust_
#ifndef _di_f_int16s_append_
- f_status_t f_int16s_append(const int16_t source, f_int16s_t *destination) {
+ f_status_t f_int16s_append(const int16_t source, f_int16s_t * const destination) {
#ifndef _di_level_0_parameter_checking_
if (!destination) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_int16s_append_
#ifndef _di_f_int16s_append_all_
- f_status_t f_int16s_append_all(const f_int16s_t source, f_int16s_t *destination) {
+ f_status_t f_int16s_append_all(const f_int16s_t source, f_int16s_t * const destination) {
#ifndef _di_level_0_parameter_checking_
if (!destination) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_int16s_append_all_
#ifndef _di_f_int16s_decimate_by_
- f_status_t f_int16s_decimate_by(const f_number_unsigned_t amount, f_int16s_t *int16s) {
+ f_status_t f_int16s_decimate_by(const f_number_unsigned_t amount, f_int16s_t * const int16s) {
#ifndef _di_level_0_parameter_checking_
if (!int16s) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_int16s_decimate_by_
#ifndef _di_f_int16s_decrease_by_
- f_status_t f_int16s_decrease_by(const f_number_unsigned_t amount, f_int16s_t *int16s) {
+ f_status_t f_int16s_decrease_by(const f_number_unsigned_t amount, f_int16s_t * const int16s) {
#ifndef _di_level_0_parameter_checking_
if (!int16s) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_int16s_decrease_by_
#ifndef _di_f_int16s_increase_
- f_status_t f_int16s_increase(const f_number_unsigned_t step, f_int16s_t *int16s) {
+ f_status_t f_int16s_increase(const f_number_unsigned_t step, f_int16s_t * const int16s) {
#ifndef _di_level_0_parameter_checking_
if (!int16s) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_int16s_increase_
#ifndef _di_f_int16s_increase_by_
- f_status_t f_int16s_increase_by(const f_number_unsigned_t amount, f_int16s_t *int16s) {
+ f_status_t f_int16s_increase_by(const f_number_unsigned_t amount, f_int16s_t * const int16s) {
#ifndef _di_level_0_parameter_checking_
if (!int16s) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_int16s_increase_by_
#ifndef _di_f_int16s_resize_
- f_status_t f_int16s_resize(const f_number_unsigned_t length, f_int16s_t *int16s) {
+ f_status_t f_int16s_resize(const f_number_unsigned_t length, f_int16s_t * const int16s) {
#ifndef _di_level_0_parameter_checking_
if (!int16s) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_int16s_resize_
#ifndef _di_f_int16ss_adjust_
- f_status_t f_int16ss_adjust(const f_number_unsigned_t length, f_int16ss_t *int16ss) {
+ f_status_t f_int16ss_adjust(const f_number_unsigned_t length, f_int16ss_t * const int16ss) {
#ifndef _di_level_0_parameter_checking_
if (!int16ss) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_int16ss_adjust_
#ifndef _di_f_int16ss_append_
- f_status_t f_int16ss_append(const f_int16s_t source, f_int16ss_t *destination) {
+ f_status_t f_int16ss_append(const f_int16s_t source, f_int16ss_t * const destination) {
#ifndef _di_level_0_parameter_checking_
if (!destination) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_int16ss_append_
#ifndef _di_f_int16ss_append_all_
- f_status_t f_int16ss_append_all(const f_int16ss_t source, f_int16ss_t *destination) {
+ f_status_t f_int16ss_append_all(const f_int16ss_t source, f_int16ss_t * const destination) {
#ifndef _di_level_0_parameter_checking_
if (!destination) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_int16ss_append_all_
#ifndef _di_f_int16ss_decimate_by_
- f_status_t f_int16ss_decimate_by(const f_number_unsigned_t amount, f_int16ss_t *int16ss) {
+ f_status_t f_int16ss_decimate_by(const f_number_unsigned_t amount, f_int16ss_t * const int16ss) {
#ifndef _di_level_0_parameter_checking_
if (!int16ss) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_int16ss_decimate_by_
#ifndef _di_f_int16ss_decrease_by_
- f_status_t f_int16ss_decrease_by(const f_number_unsigned_t amount, f_int16ss_t *int16ss) {
+ f_status_t f_int16ss_decrease_by(const f_number_unsigned_t amount, f_int16ss_t * const int16ss) {
#ifndef _di_level_0_parameter_checking_
if (!int16ss) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_int16ss_decrease_by_
#ifndef _di_f_int16ss_increase_
- f_status_t f_int16ss_increase(const f_number_unsigned_t step, f_int16ss_t *int16ss) {
+ f_status_t f_int16ss_increase(const f_number_unsigned_t step, f_int16ss_t * const int16ss) {
#ifndef _di_level_0_parameter_checking_
if (!int16ss) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_int16ss_increase_
#ifndef _di_f_int16ss_increase_by_
- f_status_t f_int16ss_increase_by(const f_number_unsigned_t amount, f_int16ss_t *int16ss) {
+ f_status_t f_int16ss_increase_by(const f_number_unsigned_t amount, f_int16ss_t * const int16ss) {
#ifndef _di_level_0_parameter_checking_
if (!int16ss) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_int16ss_increase_by_
#ifndef _di_f_int16ss_resize_
- f_status_t f_int16ss_resize(const f_number_unsigned_t length, f_int16ss_t *int16ss) {
+ f_status_t f_int16ss_resize(const f_number_unsigned_t length, f_int16ss_t * const int16ss) {
#ifndef _di_level_0_parameter_checking_
if (!int16ss) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
* Errors (with error bit) from: f_memory_adjust().
*/
#ifndef _di_f_int16s_adjust_
- extern f_status_t f_int16s_adjust(const f_number_unsigned_t length, f_int16s_t *int16s);
+ extern f_status_t f_int16s_adjust(const f_number_unsigned_t length, f_int16s_t * const int16s);
#endif // _di_f_int16s_adjust_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_int16s_append_
- extern f_status_t f_int16s_append(const int16_t source, f_int16s_t *destination);
+ extern f_status_t f_int16s_append(const int16_t source, f_int16s_t * const destination);
#endif // _di_f_int16s_append_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_int16s_append_all_
- extern f_status_t f_int16s_append_all(const f_int16s_t source, f_int16s_t *destination);
+ extern f_status_t f_int16s_append_all(const f_int16s_t source, f_int16s_t * const destination);
#endif // _di_f_int16s_append_all_
/**
* Errors (with error bit) from: f_memory_adjust().
*/
#ifndef _di_f_int16s_decimate_by_
- extern f_status_t f_int16s_decimate_by(const f_number_unsigned_t amount, f_int16s_t *int16s);
+ extern f_status_t f_int16s_decimate_by(const f_number_unsigned_t amount, f_int16s_t * const int16s);
#endif // _di_f_int16s_decimate_by_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_int16s_decrease_by_
- extern f_status_t f_int16s_decrease_by(const f_number_unsigned_t amount, f_int16s_t *int16s);
+ extern f_status_t f_int16s_decrease_by(const f_number_unsigned_t amount, f_int16s_t * const int16s);
#endif // _di_f_int16s_decrease_by_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_int16s_increase_
- extern f_status_t f_int16s_increase(const f_number_unsigned_t step, f_int16s_t *int16s);
+ extern f_status_t f_int16s_increase(const f_number_unsigned_t step, f_int16s_t * const int16s);
#endif // _di_f_int16s_increase_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_int16s_increase_by_
- extern f_status_t f_int16s_increase_by(const f_number_unsigned_t amount, f_int16s_t *int16s);
+ extern f_status_t f_int16s_increase_by(const f_number_unsigned_t amount, f_int16s_t * const int16s);
#endif // _di_f_int16s_increase_by_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_int16s_resize_
- extern f_status_t f_int16s_resize(const f_number_unsigned_t length, f_int16s_t *int16s);
+ extern f_status_t f_int16s_resize(const f_number_unsigned_t length, f_int16s_t * const int16s);
#endif // _di_f_int16s_resize_
/**
* Errors (with error bit) from: f_memory_destroy().
*/
#ifndef _di_f_int16ss_adjust_
- extern f_status_t f_int16ss_adjust(const f_number_unsigned_t length, f_int16ss_t *int16ss);
+ extern f_status_t f_int16ss_adjust(const f_number_unsigned_t length, f_int16ss_t * const int16ss);
#endif // _di_f_int16ss_adjust_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_int16ss_append_
- extern f_status_t f_int16ss_append(const f_int16s_t source, f_int16ss_t *destination);
+ extern f_status_t f_int16ss_append(const f_int16s_t source, f_int16ss_t * const destination);
#endif // _di_f_int16ss_append_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_int16ss_append_all_
- extern f_status_t f_int16ss_append_all(const f_int16ss_t source, f_int16ss_t *destination);
+ extern f_status_t f_int16ss_append_all(const f_int16ss_t source, f_int16ss_t * const destination);
#endif // _di_f_int16ss_append_all_
/**
* Errors (with error bit) from: f_memory_destroy().
*/
#ifndef _di_f_int16ss_decimate_by_
- extern f_status_t f_int16ss_decimate_by(const f_number_unsigned_t amount, f_int16ss_t *int16ss);
+ extern f_status_t f_int16ss_decimate_by(const f_number_unsigned_t amount, f_int16ss_t * const int16ss);
#endif // _di_f_int16ss_decimate_by_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_int16ss_decrease_by_
- extern f_status_t f_int16ss_decrease_by(const f_number_unsigned_t amount, f_int16ss_t *int16ss);
+ extern f_status_t f_int16ss_decrease_by(const f_number_unsigned_t amount, f_int16ss_t * const int16ss);
#endif // _di_f_int16ss_decrease_by_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_int16ss_increase_
- extern f_status_t f_int16ss_increase(const f_number_unsigned_t step, f_int16ss_t *int16ss);
+ extern f_status_t f_int16ss_increase(const f_number_unsigned_t step, f_int16ss_t * const int16ss);
#endif // _di_f_int16ss_increase_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_int16ss_increase_by_
- extern f_status_t f_int16ss_increase_by(const f_number_unsigned_t amount, f_int16ss_t *int16ss);
+ extern f_status_t f_int16ss_increase_by(const f_number_unsigned_t amount, f_int16ss_t * const int16ss);
#endif // _di_f_int16ss_increase_by_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_int16ss_resize_
- extern f_status_t f_int16ss_resize(const f_number_unsigned_t length, f_int16ss_t *int16ss);
+ extern f_status_t f_int16ss_resize(const f_number_unsigned_t length, f_int16ss_t * const int16ss);
#endif // _di_f_int16ss_resize_
#ifdef __cplusplus
#endif
#ifndef _di_f_int32s_adjust_
- f_status_t f_int32s_adjust(const f_number_unsigned_t length, f_int32s_t *int32s) {
+ f_status_t f_int32s_adjust(const f_number_unsigned_t length, f_int32s_t * const int32s) {
#ifndef _di_level_0_parameter_checking_
if (!int32s) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_int32s_adjust_
#ifndef _di_f_int32s_append_
- f_status_t f_int32s_append(const int32_t source, f_int32s_t *destination) {
+ f_status_t f_int32s_append(const int32_t source, f_int32s_t * const destination) {
#ifndef _di_level_0_parameter_checking_
if (!destination) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_int32s_append_
#ifndef _di_f_int32s_append_all_
- f_status_t f_int32s_append_all(const f_int32s_t source, f_int32s_t *destination) {
+ f_status_t f_int32s_append_all(const f_int32s_t source, f_int32s_t * const destination) {
#ifndef _di_level_0_parameter_checking_
if (!destination) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_int32s_append_all_
#ifndef _di_f_int32s_decimate_by_
- f_status_t f_int32s_decimate_by(const f_number_unsigned_t amount, f_int32s_t *int32s) {
+ f_status_t f_int32s_decimate_by(const f_number_unsigned_t amount, f_int32s_t * const int32s) {
#ifndef _di_level_0_parameter_checking_
if (!int32s) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_int32s_decimate_by_
#ifndef _di_f_int32s_decrease_by_
- f_status_t f_int32s_decrease_by(const f_number_unsigned_t amount, f_int32s_t *int32s) {
+ f_status_t f_int32s_decrease_by(const f_number_unsigned_t amount, f_int32s_t * const int32s) {
#ifndef _di_level_0_parameter_checking_
if (!int32s) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_int32s_decrease_by_
#ifndef _di_f_int32s_increase_
- f_status_t f_int32s_increase(const f_number_unsigned_t step, f_int32s_t *int32s) {
+ f_status_t f_int32s_increase(const f_number_unsigned_t step, f_int32s_t * const int32s) {
#ifndef _di_level_0_parameter_checking_
if (!int32s) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_int32s_increase_
#ifndef _di_f_int32s_increase_by_
- f_status_t f_int32s_increase_by(const f_number_unsigned_t amount, f_int32s_t *int32s) {
+ f_status_t f_int32s_increase_by(const f_number_unsigned_t amount, f_int32s_t * const int32s) {
#ifndef _di_level_0_parameter_checking_
if (!int32s) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_int32s_increase_by_
#ifndef _di_f_int32s_resize_
- f_status_t f_int32s_resize(const f_number_unsigned_t length, f_int32s_t *int32s) {
+ f_status_t f_int32s_resize(const f_number_unsigned_t length, f_int32s_t * const int32s) {
#ifndef _di_level_0_parameter_checking_
if (!int32s) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_int32s_resize_
#ifndef _di_f_int32ss_adjust_
- f_status_t f_int32ss_adjust(const f_number_unsigned_t length, f_int32ss_t *int32ss) {
+ f_status_t f_int32ss_adjust(const f_number_unsigned_t length, f_int32ss_t * const int32ss) {
#ifndef _di_level_0_parameter_checking_
if (!int32ss) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_int32ss_adjust_
#ifndef _di_f_int32ss_append_
- f_status_t f_int32ss_append(const f_int32s_t source, f_int32ss_t *destination) {
+ f_status_t f_int32ss_append(const f_int32s_t source, f_int32ss_t * const destination) {
#ifndef _di_level_0_parameter_checking_
if (!destination) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_int32ss_append_
#ifndef _di_f_int32ss_append_all_
- f_status_t f_int32ss_append_all(const f_int32ss_t source, f_int32ss_t *destination) {
+ f_status_t f_int32ss_append_all(const f_int32ss_t source, f_int32ss_t * const destination) {
#ifndef _di_level_0_parameter_checking_
if (!destination) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_int32ss_append_all_
#ifndef _di_f_int32ss_decimate_by_
- f_status_t f_int32ss_decimate_by(const f_number_unsigned_t amount, f_int32ss_t *int32ss) {
+ f_status_t f_int32ss_decimate_by(const f_number_unsigned_t amount, f_int32ss_t * const int32ss) {
#ifndef _di_level_0_parameter_checking_
if (!int32ss) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_int32ss_decimate_by_
#ifndef _di_f_int32ss_decrease_by_
- f_status_t f_int32ss_decrease_by(const f_number_unsigned_t amount, f_int32ss_t *int32ss) {
+ f_status_t f_int32ss_decrease_by(const f_number_unsigned_t amount, f_int32ss_t * const int32ss) {
#ifndef _di_level_0_parameter_checking_
if (!int32ss) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_int32ss_decrease_by_
#ifndef _di_f_int32ss_increase_
- f_status_t f_int32ss_increase(const f_number_unsigned_t step, f_int32ss_t *int32ss) {
+ f_status_t f_int32ss_increase(const f_number_unsigned_t step, f_int32ss_t * const int32ss) {
#ifndef _di_level_0_parameter_checking_
if (!int32ss) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_int32ss_increase_
#ifndef _di_f_int32ss_increase_by_
- f_status_t f_int32ss_increase_by(const f_number_unsigned_t amount, f_int32ss_t *int32ss) {
+ f_status_t f_int32ss_increase_by(const f_number_unsigned_t amount, f_int32ss_t * const int32ss) {
#ifndef _di_level_0_parameter_checking_
if (!int32ss) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_int32ss_increase_by_
#ifndef _di_f_int32ss_resize_
- f_status_t f_int32ss_resize(const f_number_unsigned_t length, f_int32ss_t *int32ss) {
+ f_status_t f_int32ss_resize(const f_number_unsigned_t length, f_int32ss_t * const int32ss) {
#ifndef _di_level_0_parameter_checking_
if (!int32ss) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
* Errors (with error bit) from: f_memory_adjust().
*/
#ifndef _di_f_int32s_adjust_
- extern f_status_t f_int32s_adjust(const f_number_unsigned_t length, f_int32s_t *int32s);
+ extern f_status_t f_int32s_adjust(const f_number_unsigned_t length, f_int32s_t * const int32s);
#endif // _di_f_int32s_adjust_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_int32s_append_
- extern f_status_t f_int32s_append(const int32_t source, f_int32s_t *destination);
+ extern f_status_t f_int32s_append(const int32_t source, f_int32s_t * const destination);
#endif // _di_f_int32s_append_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_int32s_append_all_
- extern f_status_t f_int32s_append_all(const f_int32s_t source, f_int32s_t *destination);
+ extern f_status_t f_int32s_append_all(const f_int32s_t source, f_int32s_t * const destination);
#endif // _di_f_int32s_append_all_
/**
* Errors (with error bit) from: f_memory_adjust().
*/
#ifndef _di_f_int32s_decimate_by_
- extern f_status_t f_int32s_decimate_by(const f_number_unsigned_t amount, f_int32s_t *int32s);
+ extern f_status_t f_int32s_decimate_by(const f_number_unsigned_t amount, f_int32s_t * const int32s);
#endif // _di_f_int32s_decimate_by_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_int32s_decrease_by_
- extern f_status_t f_int32s_decrease_by(const f_number_unsigned_t amount, f_int32s_t *int32s);
+ extern f_status_t f_int32s_decrease_by(const f_number_unsigned_t amount, f_int32s_t * const int32s);
#endif // _di_f_int32s_decrease_by_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_int32s_increase_
- extern f_status_t f_int32s_increase(const f_number_unsigned_t step, f_int32s_t *int32s);
+ extern f_status_t f_int32s_increase(const f_number_unsigned_t step, f_int32s_t * const int32s);
#endif // _di_f_int32s_increase_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_int32s_increase_by_
- extern f_status_t f_int32s_increase_by(const f_number_unsigned_t amount, f_int32s_t *int32s);
+ extern f_status_t f_int32s_increase_by(const f_number_unsigned_t amount, f_int32s_t * const int32s);
#endif // _di_f_int32s_increase_by_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_int32s_resize_
- extern f_status_t f_int32s_resize(const f_number_unsigned_t length, f_int32s_t *int32s);
+ extern f_status_t f_int32s_resize(const f_number_unsigned_t length, f_int32s_t * const int32s);
#endif // _di_f_int32s_resize_
/**
* Errors (with error bit) from: f_memory_destroy().
*/
#ifndef _di_f_int32ss_adjust_
- extern f_status_t f_int32ss_adjust(const f_number_unsigned_t length, f_int32ss_t *int32ss);
+ extern f_status_t f_int32ss_adjust(const f_number_unsigned_t length, f_int32ss_t * const int32ss);
#endif // _di_f_int32ss_adjust_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_int32ss_append_
- extern f_status_t f_int32ss_append(const f_int32s_t source, f_int32ss_t *destination);
+ extern f_status_t f_int32ss_append(const f_int32s_t source, f_int32ss_t * const destination);
#endif // _di_f_int32ss_append_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_int32ss_append_all_
- extern f_status_t f_int32ss_append_all(const f_int32ss_t source, f_int32ss_t *destination);
+ extern f_status_t f_int32ss_append_all(const f_int32ss_t source, f_int32ss_t * const destination);
#endif // _di_f_int32ss_append_all_
/**
* Errors (with error bit) from: f_memory_destroy().
*/
#ifndef _di_f_int32ss_decimate_by_
- extern f_status_t f_int32ss_decimate_by(const f_number_unsigned_t amount, f_int32ss_t *int32ss);
+ extern f_status_t f_int32ss_decimate_by(const f_number_unsigned_t amount, f_int32ss_t * const int32ss);
#endif // _di_f_int32ss_decimate_by_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_int32ss_decrease_by_
- extern f_status_t f_int32ss_decrease_by(const f_number_unsigned_t amount, f_int32ss_t *int32ss);
+ extern f_status_t f_int32ss_decrease_by(const f_number_unsigned_t amount, f_int32ss_t * const int32ss);
#endif // _di_f_int32ss_decrease_by_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_int32ss_increase_
- extern f_status_t f_int32ss_increase(const f_number_unsigned_t step, f_int32ss_t *int32ss);
+ extern f_status_t f_int32ss_increase(const f_number_unsigned_t step, f_int32ss_t * const int32ss);
#endif // _di_f_int32ss_increase_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_int32ss_increase_by_
- extern f_status_t f_int32ss_increase_by(const f_number_unsigned_t amount, f_int32ss_t *int32ss);
+ extern f_status_t f_int32ss_increase_by(const f_number_unsigned_t amount, f_int32ss_t * const int32ss);
#endif // _di_f_int32ss_increase_by_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_int32ss_resize_
- extern f_status_t f_int32ss_resize(const f_number_unsigned_t length, f_int32ss_t *int32ss);
+ extern f_status_t f_int32ss_resize(const f_number_unsigned_t length, f_int32ss_t * const int32ss);
#endif // _di_f_int32ss_resize_
#ifdef __cplusplus
#endif
#ifndef _di_f_int64s_adjust_
- f_status_t f_int64s_adjust(const f_number_unsigned_t length, f_int64s_t *int64s) {
+ f_status_t f_int64s_adjust(const f_number_unsigned_t length, f_int64s_t * const int64s) {
#ifndef _di_level_0_parameter_checking_
if (!int64s) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_int64s_adjust_
#ifndef _di_f_int64s_append_
- f_status_t f_int64s_append(const int64_t source, f_int64s_t *destination) {
+ f_status_t f_int64s_append(const int64_t source, f_int64s_t * const destination) {
#ifndef _di_level_0_parameter_checking_
if (!destination) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_int64s_append_
#ifndef _di_f_int64s_append_all_
- f_status_t f_int64s_append_all(const f_int64s_t source, f_int64s_t *destination) {
+ f_status_t f_int64s_append_all(const f_int64s_t source, f_int64s_t * const destination) {
#ifndef _di_level_0_parameter_checking_
if (!destination) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_int64s_append_all_
#ifndef _di_f_int64s_decimate_by_
- f_status_t f_int64s_decimate_by(const f_number_unsigned_t amount, f_int64s_t *int64s) {
+ f_status_t f_int64s_decimate_by(const f_number_unsigned_t amount, f_int64s_t * const int64s) {
#ifndef _di_level_0_parameter_checking_
if (!int64s) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_int64s_decimate_by_
#ifndef _di_f_int64s_decrease_by_
- f_status_t f_int64s_decrease_by(const f_number_unsigned_t amount, f_int64s_t *int64s) {
+ f_status_t f_int64s_decrease_by(const f_number_unsigned_t amount, f_int64s_t * const int64s) {
#ifndef _di_level_0_parameter_checking_
if (!int64s) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_int64s_decrease_by_
#ifndef _di_f_int64s_increase_
- f_status_t f_int64s_increase(const f_number_unsigned_t step, f_int64s_t *int64s) {
+ f_status_t f_int64s_increase(const f_number_unsigned_t step, f_int64s_t * const int64s) {
#ifndef _di_level_0_parameter_checking_
if (!int64s) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_int64s_increase_
#ifndef _di_f_int64s_increase_by_
- f_status_t f_int64s_increase_by(const f_number_unsigned_t amount, f_int64s_t *int64s) {
+ f_status_t f_int64s_increase_by(const f_number_unsigned_t amount, f_int64s_t * const int64s) {
#ifndef _di_level_0_parameter_checking_
if (!int64s) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_int64s_increase_by_
#ifndef _di_f_int64s_resize_
- f_status_t f_int64s_resize(const f_number_unsigned_t length, f_int64s_t *int64s) {
+ f_status_t f_int64s_resize(const f_number_unsigned_t length, f_int64s_t * const int64s) {
#ifndef _di_level_0_parameter_checking_
if (!int64s) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_int64s_resize_
#ifndef _di_f_int64ss_adjust_
- f_status_t f_int64ss_adjust(const f_number_unsigned_t length, f_int64ss_t *int64ss) {
+ f_status_t f_int64ss_adjust(const f_number_unsigned_t length, f_int64ss_t * const int64ss) {
#ifndef _di_level_0_parameter_checking_
if (!int64ss) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_int64ss_adjust_
#ifndef _di_f_int64ss_append_
- f_status_t f_int64ss_append(const f_int64s_t source, f_int64ss_t *destination) {
+ f_status_t f_int64ss_append(const f_int64s_t source, f_int64ss_t * const destination) {
#ifndef _di_level_0_parameter_checking_
if (!destination) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_int64ss_append_
#ifndef _di_f_int64ss_append_all_
- f_status_t f_int64ss_append_all(const f_int64ss_t source, f_int64ss_t *destination) {
+ f_status_t f_int64ss_append_all(const f_int64ss_t source, f_int64ss_t * const destination) {
#ifndef _di_level_0_parameter_checking_
if (!destination) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_int64ss_append_all_
#ifndef _di_f_int64ss_decimate_by_
- f_status_t f_int64ss_decimate_by(const f_number_unsigned_t amount, f_int64ss_t *int64ss) {
+ f_status_t f_int64ss_decimate_by(const f_number_unsigned_t amount, f_int64ss_t * const int64ss) {
#ifndef _di_level_0_parameter_checking_
if (!int64ss) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_int64ss_decimate_by_
#ifndef _di_f_int64ss_decrease_by_
- f_status_t f_int64ss_decrease_by(const f_number_unsigned_t amount, f_int64ss_t *int64ss) {
+ f_status_t f_int64ss_decrease_by(const f_number_unsigned_t amount, f_int64ss_t * const int64ss) {
#ifndef _di_level_0_parameter_checking_
if (!int64ss) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_int64ss_decrease_by_
#ifndef _di_f_int64ss_increase_
- f_status_t f_int64ss_increase(const f_number_unsigned_t step, f_int64ss_t *int64ss) {
+ f_status_t f_int64ss_increase(const f_number_unsigned_t step, f_int64ss_t * const int64ss) {
#ifndef _di_level_0_parameter_checking_
if (!int64ss) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_int64ss_increase_
#ifndef _di_f_int64ss_increase_by_
- f_status_t f_int64ss_increase_by(const f_number_unsigned_t amount, f_int64ss_t *int64ss) {
+ f_status_t f_int64ss_increase_by(const f_number_unsigned_t amount, f_int64ss_t * const int64ss) {
#ifndef _di_level_0_parameter_checking_
if (!int64ss) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_int64ss_increase_by_
#ifndef _di_f_int64ss_resize_
- f_status_t f_int64ss_resize(const f_number_unsigned_t length, f_int64ss_t *int64ss) {
+ f_status_t f_int64ss_resize(const f_number_unsigned_t length, f_int64ss_t * const int64ss) {
#ifndef _di_level_0_parameter_checking_
if (!int64ss) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
* Errors (with error bit) from: f_memory_adjust().
*/
#ifndef _di_f_int64s_adjust_
- extern f_status_t f_int64s_adjust(const f_number_unsigned_t length, f_int64s_t *int64s);
+ extern f_status_t f_int64s_adjust(const f_number_unsigned_t length, f_int64s_t * const int64s);
#endif // _di_f_int64s_adjust_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_int64s_append_
- extern f_status_t f_int64s_append(const int64_t source, f_int64s_t *destination);
+ extern f_status_t f_int64s_append(const int64_t source, f_int64s_t * const destination);
#endif // _di_f_int64s_append_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_int64s_append_all_
- extern f_status_t f_int64s_append_all(const f_int64s_t source, f_int64s_t *destination);
+ extern f_status_t f_int64s_append_all(const f_int64s_t source, f_int64s_t * const destination);
#endif // _di_f_int64s_append_all_
/**
* Errors (with error bit) from: f_memory_adjust().
*/
#ifndef _di_f_int64s_decimate_by_
- extern f_status_t f_int64s_decimate_by(const f_number_unsigned_t amount, f_int64s_t *int64s);
+ extern f_status_t f_int64s_decimate_by(const f_number_unsigned_t amount, f_int64s_t * const int64s);
#endif // _di_f_int64s_decimate_by_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_int64s_decrease_by_
- extern f_status_t f_int64s_decrease_by(const f_number_unsigned_t amount, f_int64s_t *int64s);
+ extern f_status_t f_int64s_decrease_by(const f_number_unsigned_t amount, f_int64s_t * const int64s);
#endif // _di_f_int64s_decrease_by_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_int64s_increase_
- extern f_status_t f_int64s_increase(const f_number_unsigned_t step, f_int64s_t *int64s);
+ extern f_status_t f_int64s_increase(const f_number_unsigned_t step, f_int64s_t * const int64s);
#endif // _di_f_int64s_increase_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_int64s_increase_by_
- extern f_status_t f_int64s_increase_by(const f_number_unsigned_t amount, f_int64s_t *int64s);
+ extern f_status_t f_int64s_increase_by(const f_number_unsigned_t amount, f_int64s_t * const int64s);
#endif // _di_f_int64s_increase_by_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_int64s_resize_
- extern f_status_t f_int64s_resize(const f_number_unsigned_t length, f_int64s_t *int64s);
+ extern f_status_t f_int64s_resize(const f_number_unsigned_t length, f_int64s_t * const int64s);
#endif // _di_f_int64s_resize_
/**
* Errors (with error bit) from: f_memory_destroy().
*/
#ifndef _di_f_int64ss_adjust_
- extern f_status_t f_int64ss_adjust(const f_number_unsigned_t length, f_int64ss_t *int64ss);
+ extern f_status_t f_int64ss_adjust(const f_number_unsigned_t length, f_int64ss_t * const int64ss);
#endif // _di_f_int64ss_adjust_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_int64ss_append_
- extern f_status_t f_int64ss_append(const f_int64s_t source, f_int64ss_t *destination);
+ extern f_status_t f_int64ss_append(const f_int64s_t source, f_int64ss_t * const destination);
#endif // _di_f_int64ss_append_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_int64ss_append_all_
- extern f_status_t f_int64ss_append_all(const f_int64ss_t source, f_int64ss_t *destination);
+ extern f_status_t f_int64ss_append_all(const f_int64ss_t source, f_int64ss_t * const destination);
#endif // _di_f_int64ss_append_all_
/**
* Errors (with error bit) from: f_memory_destroy().
*/
#ifndef _di_f_int64ss_decimate_by_
- extern f_status_t f_int64ss_decimate_by(const f_number_unsigned_t amount, f_int64ss_t *int64ss);
+ extern f_status_t f_int64ss_decimate_by(const f_number_unsigned_t amount, f_int64ss_t * const int64ss);
#endif // _di_f_int64ss_decimate_by_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_int64ss_decrease_by_
- extern f_status_t f_int64ss_decrease_by(const f_number_unsigned_t amount, f_int64ss_t *int64ss);
+ extern f_status_t f_int64ss_decrease_by(const f_number_unsigned_t amount, f_int64ss_t * const int64ss);
#endif // _di_f_int64ss_decrease_by_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_int64ss_increase_
- extern f_status_t f_int64ss_increase(const f_number_unsigned_t step, f_int64ss_t *int64ss);
+ extern f_status_t f_int64ss_increase(const f_number_unsigned_t step, f_int64ss_t * const int64ss);
#endif // _di_f_int64ss_increase_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_int64ss_increase_by_
- extern f_status_t f_int64ss_increase_by(const f_number_unsigned_t amount, f_int64ss_t *int64ss);
+ extern f_status_t f_int64ss_increase_by(const f_number_unsigned_t amount, f_int64ss_t * const int64ss);
#endif // _di_f_int64ss_increase_by_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_int64ss_resize_
- extern f_status_t f_int64ss_resize(const f_number_unsigned_t length, f_int64ss_t *int64ss);
+ extern f_status_t f_int64ss_resize(const f_number_unsigned_t length, f_int64ss_t * const int64ss);
#endif // _di_f_int64ss_resize_
#ifdef __cplusplus
#endif
#ifndef _di_f_int8s_adjust_
- f_status_t f_int8s_adjust(const f_number_unsigned_t length, f_int8s_t *int8s) {
+ f_status_t f_int8s_adjust(const f_number_unsigned_t length, f_int8s_t * const int8s) {
#ifndef _di_level_0_parameter_checking_
if (!int8s) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_int8s_adjust_
#ifndef _di_f_int8s_append_
- f_status_t f_int8s_append(const int8_t source, f_int8s_t *destination) {
+ f_status_t f_int8s_append(const int8_t source, f_int8s_t * const destination) {
#ifndef _di_level_0_parameter_checking_
if (!destination) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_int8s_append_
#ifndef _di_f_int8s_append_all_
- f_status_t f_int8s_append_all(const f_int8s_t source, f_int8s_t *destination) {
+ f_status_t f_int8s_append_all(const f_int8s_t source, f_int8s_t * const destination) {
#ifndef _di_level_0_parameter_checking_
if (!destination) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_int8s_append_all_
#ifndef _di_f_int8s_decimate_by_
- f_status_t f_int8s_decimate_by(const f_number_unsigned_t amount, f_int8s_t *int8s) {
+ f_status_t f_int8s_decimate_by(const f_number_unsigned_t amount, f_int8s_t * const int8s) {
#ifndef _di_level_0_parameter_checking_
if (!int8s) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_int8s_decimate_by_
#ifndef _di_f_int8s_decrease_by_
- f_status_t f_int8s_decrease_by(const f_number_unsigned_t amount, f_int8s_t *int8s) {
+ f_status_t f_int8s_decrease_by(const f_number_unsigned_t amount, f_int8s_t * const int8s) {
#ifndef _di_level_0_parameter_checking_
if (!int8s) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_int8s_decrease_by_
#ifndef _di_f_int8s_increase_
- f_status_t f_int8s_increase(const f_number_unsigned_t step, f_int8s_t *int8s) {
+ f_status_t f_int8s_increase(const f_number_unsigned_t step, f_int8s_t * const int8s) {
#ifndef _di_level_0_parameter_checking_
if (!int8s) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_int8s_increase_
#ifndef _di_f_int8s_increase_by_
- f_status_t f_int8s_increase_by(const f_number_unsigned_t amount, f_int8s_t *int8s) {
+ f_status_t f_int8s_increase_by(const f_number_unsigned_t amount, f_int8s_t * const int8s) {
#ifndef _di_level_0_parameter_checking_
if (!int8s) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_int8s_increase_by_
#ifndef _di_f_int8s_resize_
- f_status_t f_int8s_resize(const f_number_unsigned_t length, f_int8s_t *int8s) {
+ f_status_t f_int8s_resize(const f_number_unsigned_t length, f_int8s_t * const int8s) {
#ifndef _di_level_0_parameter_checking_
if (!int8s) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_int8s_resize_
#ifndef _di_f_int8ss_adjust_
- f_status_t f_int8ss_adjust(const f_number_unsigned_t length, f_int8ss_t *int8ss) {
+ f_status_t f_int8ss_adjust(const f_number_unsigned_t length, f_int8ss_t * const int8ss) {
#ifndef _di_level_0_parameter_checking_
if (!int8ss) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_int8ss_adjust_
#ifndef _di_f_int8ss_append_
- f_status_t f_int8ss_append(const f_int8s_t source, f_int8ss_t *destination) {
+ f_status_t f_int8ss_append(const f_int8s_t source, f_int8ss_t * const destination) {
#ifndef _di_level_0_parameter_checking_
if (!destination) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_int8ss_append_
#ifndef _di_f_int8ss_append_all_
- f_status_t f_int8ss_append_all(const f_int8ss_t source, f_int8ss_t *destination) {
+ f_status_t f_int8ss_append_all(const f_int8ss_t source, f_int8ss_t * const destination) {
#ifndef _di_level_0_parameter_checking_
if (!destination) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_int8ss_append_all_
#ifndef _di_f_int8ss_decimate_by_
- f_status_t f_int8ss_decimate_by(const f_number_unsigned_t amount, f_int8ss_t *int8ss) {
+ f_status_t f_int8ss_decimate_by(const f_number_unsigned_t amount, f_int8ss_t * const int8ss) {
#ifndef _di_level_0_parameter_checking_
if (!int8ss) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_int8ss_decimate_by_
#ifndef _di_f_int8ss_decrease_by_
- f_status_t f_int8ss_decrease_by(const f_number_unsigned_t amount, f_int8ss_t *int8ss) {
+ f_status_t f_int8ss_decrease_by(const f_number_unsigned_t amount, f_int8ss_t * const int8ss) {
#ifndef _di_level_0_parameter_checking_
if (!int8ss) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_int8ss_decrease_by_
#ifndef _di_f_int8ss_increase_
- f_status_t f_int8ss_increase(const f_number_unsigned_t step, f_int8ss_t *int8ss) {
+ f_status_t f_int8ss_increase(const f_number_unsigned_t step, f_int8ss_t * const int8ss) {
#ifndef _di_level_0_parameter_checking_
if (!int8ss) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_int8ss_increase_
#ifndef _di_f_int8ss_increase_by_
- f_status_t f_int8ss_increase_by(const f_number_unsigned_t amount, f_int8ss_t *int8ss) {
+ f_status_t f_int8ss_increase_by(const f_number_unsigned_t amount, f_int8ss_t * const int8ss) {
#ifndef _di_level_0_parameter_checking_
if (!int8ss) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_int8ss_increase_by_
#ifndef _di_f_int8ss_resize_
- f_status_t f_int8ss_resize(const f_number_unsigned_t length, f_int8ss_t *int8ss) {
+ f_status_t f_int8ss_resize(const f_number_unsigned_t length, f_int8ss_t * const int8ss) {
#ifndef _di_level_0_parameter_checking_
if (!int8ss) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
* Errors (with error bit) from: f_memory_adjust().
*/
#ifndef _di_f_int8s_adjust_
- extern f_status_t f_int8s_adjust(const f_number_unsigned_t length, f_int8s_t *int8s);
+ extern f_status_t f_int8s_adjust(const f_number_unsigned_t length, f_int8s_t * const int8s);
#endif // _di_f_int8s_adjust_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_int8s_append_
- extern f_status_t f_int8s_append(const int8_t source, f_int8s_t *destination);
+ extern f_status_t f_int8s_append(const int8_t source, f_int8s_t * const destination);
#endif // _di_f_int8s_append_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_int8s_append_all_
- extern f_status_t f_int8s_append_all(const f_int8s_t source, f_int8s_t *destination);
+ extern f_status_t f_int8s_append_all(const f_int8s_t source, f_int8s_t * const destination);
#endif // _di_f_int8s_append_all_
/**
* Errors (with error bit) from: f_memory_adjust().
*/
#ifndef _di_f_int8s_decimate_by_
- extern f_status_t f_int8s_decimate_by(const f_number_unsigned_t amount, f_int8s_t *int8s);
+ extern f_status_t f_int8s_decimate_by(const f_number_unsigned_t amount, f_int8s_t * const int8s);
#endif // _di_f_int8s_decimate_by_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_int8s_decrease_by_
- extern f_status_t f_int8s_decrease_by(const f_number_unsigned_t amount, f_int8s_t *int8s);
+ extern f_status_t f_int8s_decrease_by(const f_number_unsigned_t amount, f_int8s_t * const int8s);
#endif // _di_f_int8s_decrease_by_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_int8s_increase_
- extern f_status_t f_int8s_increase(const f_number_unsigned_t step, f_int8s_t *int8s);
+ extern f_status_t f_int8s_increase(const f_number_unsigned_t step, f_int8s_t * const int8s);
#endif // _di_f_int8s_increase_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_int8s_increase_by_
- extern f_status_t f_int8s_increase_by(const f_number_unsigned_t amount, f_int8s_t *int8s);
+ extern f_status_t f_int8s_increase_by(const f_number_unsigned_t amount, f_int8s_t * const int8s);
#endif // _di_f_int8s_increase_by_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_int8s_resize_
- extern f_status_t f_int8s_resize(const f_number_unsigned_t length, f_int8s_t *int8s);
+ extern f_status_t f_int8s_resize(const f_number_unsigned_t length, f_int8s_t * const int8s);
#endif // _di_f_int8s_resize_
/**
* Errors (with error bit) from: f_memory_destroy().
*/
#ifndef _di_f_int8ss_adjust_
- extern f_status_t f_int8ss_adjust(const f_number_unsigned_t length, f_int8ss_t *int8ss);
+ extern f_status_t f_int8ss_adjust(const f_number_unsigned_t length, f_int8ss_t * const int8ss);
#endif // _di_f_int8ss_adjust_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_int8ss_append_
- extern f_status_t f_int8ss_append(const f_int8s_t source, f_int8ss_t *destination);
+ extern f_status_t f_int8ss_append(const f_int8s_t source, f_int8ss_t * const destination);
#endif // _di_f_int8ss_append_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_int8ss_append_all_
- extern f_status_t f_int8ss_append_all(const f_int8ss_t source, f_int8ss_t *destination);
+ extern f_status_t f_int8ss_append_all(const f_int8ss_t source, f_int8ss_t * const destination);
#endif // _di_f_int8ss_append_all_
/**
* Errors (with error bit) from: f_memory_destroy().
*/
#ifndef _di_f_int8ss_decimate_by_
- extern f_status_t f_int8ss_decimate_by(const f_number_unsigned_t amount, f_int8ss_t *int8ss);
+ extern f_status_t f_int8ss_decimate_by(const f_number_unsigned_t amount, f_int8ss_t * const int8ss);
#endif // _di_f_int8ss_decimate_by_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_int8ss_decrease_by_
- extern f_status_t f_int8ss_decrease_by(const f_number_unsigned_t amount, f_int8ss_t *int8ss);
+ extern f_status_t f_int8ss_decrease_by(const f_number_unsigned_t amount, f_int8ss_t * const int8ss);
#endif // _di_f_int8ss_decrease_by_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_int8ss_increase_
- extern f_status_t f_int8ss_increase(const f_number_unsigned_t step, f_int8ss_t *int8ss);
+ extern f_status_t f_int8ss_increase(const f_number_unsigned_t step, f_int8ss_t * const int8ss);
#endif // _di_f_int8ss_increase_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_int8ss_increase_by_
- extern f_status_t f_int8ss_increase_by(const f_number_unsigned_t amount, f_int8ss_t *int8ss);
+ extern f_status_t f_int8ss_increase_by(const f_number_unsigned_t amount, f_int8ss_t * const int8ss);
#endif // _di_f_int8ss_increase_by_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_int8ss_resize_
- extern f_status_t f_int8ss_resize(const f_number_unsigned_t length, f_int8ss_t *int8ss);
+ extern f_status_t f_int8ss_resize(const f_number_unsigned_t length, f_int8ss_t * const int8ss);
#endif // _di_f_int8ss_resize_
#ifdef __cplusplus
#endif
#ifndef _di_f_number_unsigneds_adjust_
- f_status_t f_number_unsigneds_adjust(const f_number_unsigned_t length, f_number_unsigneds_t *lengths) {
+ f_status_t f_number_unsigneds_adjust(const f_number_unsigned_t length, f_number_unsigneds_t * const lengths) {
#ifndef _di_level_0_parameter_checking_
if (!lengths) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_number_unsigneds_adjust_
#ifndef _di_f_number_unsigneds_append_
- f_status_t f_number_unsigneds_append(const f_number_unsigned_t source, f_number_unsigneds_t *destination) {
+ f_status_t f_number_unsigneds_append(const f_number_unsigned_t source, f_number_unsigneds_t * const destination) {
#ifndef _di_level_0_parameter_checking_
if (!destination) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_number_unsigneds_append_
#ifndef _di_f_number_unsigneds_append_all_
- f_status_t f_number_unsigneds_append_all(const f_number_unsigneds_t source, f_number_unsigneds_t *destination) {
+ f_status_t f_number_unsigneds_append_all(const f_number_unsigneds_t source, f_number_unsigneds_t * const destination) {
#ifndef _di_level_0_parameter_checking_
if (!destination) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_number_unsigneds_append_all_
#ifndef _di_f_number_unsigneds_decimate_by_
- f_status_t f_number_unsigneds_decimate_by(const f_number_unsigned_t amount, f_number_unsigneds_t *lengths) {
+ f_status_t f_number_unsigneds_decimate_by(const f_number_unsigned_t amount, f_number_unsigneds_t * const lengths) {
#ifndef _di_level_0_parameter_checking_
if (!lengths) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_number_unsigneds_decimate_by_
#ifndef _di_f_number_unsigneds_decrease_by_
- f_status_t f_number_unsigneds_decrease_by(const f_number_unsigned_t amount, f_number_unsigneds_t *lengths) {
+ f_status_t f_number_unsigneds_decrease_by(const f_number_unsigned_t amount, f_number_unsigneds_t * const lengths) {
#ifndef _di_level_0_parameter_checking_
if (!lengths) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_number_unsigneds_decrease_by_
#ifndef _di_f_number_unsigneds_increase_
- f_status_t f_number_unsigneds_increase(const f_number_unsigned_t step, f_number_unsigneds_t *lengths) {
+ f_status_t f_number_unsigneds_increase(const f_number_unsigned_t step, f_number_unsigneds_t * const lengths) {
#ifndef _di_level_0_parameter_checking_
if (!lengths) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_number_unsigneds_increase_
#ifndef _di_f_number_unsigneds_increase_by_
- f_status_t f_number_unsigneds_increase_by(const f_number_unsigned_t amount, f_number_unsigneds_t *lengths) {
+ f_status_t f_number_unsigneds_increase_by(const f_number_unsigned_t amount, f_number_unsigneds_t * const lengths) {
#ifndef _di_level_0_parameter_checking_
if (!lengths) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_number_unsigneds_increase_by_
#ifndef _di_f_number_unsigneds_resize_
- f_status_t f_number_unsigneds_resize(const f_number_unsigned_t length, f_number_unsigneds_t *lengths) {
+ f_status_t f_number_unsigneds_resize(const f_number_unsigned_t length, f_number_unsigneds_t * const lengths) {
#ifndef _di_level_0_parameter_checking_
if (!lengths) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_number_unsigneds_resize_
#ifndef _di_f_number_unsignedss_adjust_
- f_status_t f_number_unsignedss_adjust(const f_number_unsigned_t length, f_number_unsignedss_t *lengthss) {
+ f_status_t f_number_unsignedss_adjust(const f_number_unsigned_t length, f_number_unsignedss_t * const lengthss) {
#ifndef _di_level_0_parameter_checking_
if (!lengthss) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_number_unsignedss_adjust_
#ifndef _di_f_number_unsignedss_append_
- f_status_t f_number_unsignedss_append(const f_number_unsigneds_t source, f_number_unsignedss_t *destination) {
+ f_status_t f_number_unsignedss_append(const f_number_unsigneds_t source, f_number_unsignedss_t * const destination) {
#ifndef _di_level_0_parameter_checking_
if (!destination) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_number_unsignedss_append_
#ifndef _di_f_number_unsignedss_append_all_
- f_status_t f_number_unsignedss_append_all(const f_number_unsignedss_t source, f_number_unsignedss_t *destination) {
+ f_status_t f_number_unsignedss_append_all(const f_number_unsignedss_t source, f_number_unsignedss_t * const destination) {
#ifndef _di_level_0_parameter_checking_
if (!destination) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_number_unsignedss_append_all_
#ifndef _di_f_number_unsignedss_decimate_by_
- f_status_t f_number_unsignedss_decimate_by(const f_number_unsigned_t amount, f_number_unsignedss_t *lengthss) {
+ f_status_t f_number_unsignedss_decimate_by(const f_number_unsigned_t amount, f_number_unsignedss_t * const lengthss) {
#ifndef _di_level_0_parameter_checking_
if (!lengthss) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_number_unsignedss_decimate_by_
#ifndef _di_f_number_unsignedss_decrease_by_
- f_status_t f_number_unsignedss_decrease_by(const f_number_unsigned_t amount, f_number_unsignedss_t *lengthss) {
+ f_status_t f_number_unsignedss_decrease_by(const f_number_unsigned_t amount, f_number_unsignedss_t * const lengthss) {
#ifndef _di_level_0_parameter_checking_
if (!lengthss) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_number_unsignedss_decrease_by_
#ifndef _di_f_number_unsignedss_increase_
- f_status_t f_number_unsignedss_increase(const f_number_unsigned_t step, f_number_unsignedss_t *lengthss) {
+ f_status_t f_number_unsignedss_increase(const f_number_unsigned_t step, f_number_unsignedss_t * const lengthss) {
#ifndef _di_level_0_parameter_checking_
if (!lengthss) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_number_unsignedss_increase_
#ifndef _di_f_number_unsignedss_increase_by_
- f_status_t f_number_unsignedss_increase_by(const f_number_unsigned_t amount, f_number_unsignedss_t *lengthss) {
+ f_status_t f_number_unsignedss_increase_by(const f_number_unsigned_t amount, f_number_unsignedss_t * const lengthss) {
#ifndef _di_level_0_parameter_checking_
if (!lengthss) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_number_unsignedss_increase_by_
#ifndef _di_f_number_unsignedss_resize_
- f_status_t f_number_unsignedss_resize(const f_number_unsigned_t length, f_number_unsignedss_t *lengthss) {
+ f_status_t f_number_unsignedss_resize(const f_number_unsigned_t length, f_number_unsignedss_t * const lengthss) {
#ifndef _di_level_0_parameter_checking_
if (!lengthss) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
* Errors (with error bit) from: f_memory_adjust().
*/
#ifndef _di_f_number_unsigneds_adjust_
- extern f_status_t f_number_unsigneds_adjust(const f_number_unsigned_t length, f_number_unsigneds_t *lengths);
+ extern f_status_t f_number_unsigneds_adjust(const f_number_unsigned_t length, f_number_unsigneds_t * const lengths);
#endif // _di_f_number_unsigneds_adjust_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_number_unsigneds_append_
- extern f_status_t f_number_unsigneds_append(const f_number_unsigned_t source, f_number_unsigneds_t *destination);
+ extern f_status_t f_number_unsigneds_append(const f_number_unsigned_t source, f_number_unsigneds_t * const destination);
#endif // _di_f_number_unsigneds_append_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_number_unsigneds_append_all_
- extern f_status_t f_number_unsigneds_append_all(const f_number_unsigneds_t source, f_number_unsigneds_t *destination);
+ extern f_status_t f_number_unsigneds_append_all(const f_number_unsigneds_t source, f_number_unsigneds_t * const destination);
#endif // _di_f_number_unsigneds_append_all_
/**
* Errors (with error bit) from: f_memory_adjust().
*/
#ifndef _di_f_number_unsigneds_decimate_by_
- extern f_status_t f_number_unsigneds_decimate_by(const f_number_unsigned_t amount, f_number_unsigneds_t *lengths);
+ extern f_status_t f_number_unsigneds_decimate_by(const f_number_unsigned_t amount, f_number_unsigneds_t * const lengths);
#endif // _di_f_number_unsigneds_decimate_by_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_number_unsigneds_decrease_by_
- extern f_status_t f_number_unsigneds_decrease_by(const f_number_unsigned_t amount, f_number_unsigneds_t *lengths);
+ extern f_status_t f_number_unsigneds_decrease_by(const f_number_unsigned_t amount, f_number_unsigneds_t * const lengths);
#endif // _di_f_number_unsigneds_decrease_by_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_number_unsigneds_increase_
- extern f_status_t f_number_unsigneds_increase(const f_number_unsigned_t step, f_number_unsigneds_t *lengths);
+ extern f_status_t f_number_unsigneds_increase(const f_number_unsigned_t step, f_number_unsigneds_t * const lengths);
#endif // _di_f_number_unsigneds_increase_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_number_unsigneds_increase_by_
- extern f_status_t f_number_unsigneds_increase_by(const f_number_unsigned_t amount, f_number_unsigneds_t *lengths);
+ extern f_status_t f_number_unsigneds_increase_by(const f_number_unsigned_t amount, f_number_unsigneds_t * const lengths);
#endif // _di_f_number_unsigneds_increase_by_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_number_unsigneds_resize_
- extern f_status_t f_number_unsigneds_resize(const f_number_unsigned_t length, f_number_unsigneds_t *lengths);
+ extern f_status_t f_number_unsigneds_resize(const f_number_unsigned_t length, f_number_unsigneds_t * const lengths);
#endif // _di_f_number_unsigneds_resize_
/**
* Errors (with error bit) from: f_memory_destroy().
*/
#ifndef _di_f_number_unsignedss_adjust_
- extern f_status_t f_number_unsignedss_adjust(const f_number_unsigned_t length, f_number_unsignedss_t *lengthss);
+ extern f_status_t f_number_unsignedss_adjust(const f_number_unsigned_t length, f_number_unsignedss_t * const lengthss);
#endif // _di_f_number_unsignedss_adjust_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_number_unsignedss_append_
- extern f_status_t f_number_unsignedss_append(const f_number_unsigneds_t source, f_number_unsignedss_t *destination);
+ extern f_status_t f_number_unsignedss_append(const f_number_unsigneds_t source, f_number_unsignedss_t * const destination);
#endif // _di_f_number_unsignedss_append_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_number_unsignedss_append_all_
- extern f_status_t f_number_unsignedss_append_all(const f_number_unsignedss_t source, f_number_unsignedss_t *destination);
+ extern f_status_t f_number_unsignedss_append_all(const f_number_unsignedss_t source, f_number_unsignedss_t * const destination);
#endif // _di_f_number_unsignedss_append_all_
/**
* Errors (with error bit) from: f_memory_destroy().
*/
#ifndef _di_f_number_unsignedss_decimate_by_
- extern f_status_t f_number_unsignedss_decimate_by(const f_number_unsigned_t amount, f_number_unsignedss_t *lengthss);
+ extern f_status_t f_number_unsignedss_decimate_by(const f_number_unsigned_t amount, f_number_unsignedss_t * const lengthss);
#endif // _di_f_number_unsignedss_decimate_by_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_number_unsignedss_decrease_by_
- extern f_status_t f_number_unsignedss_decrease_by(const f_number_unsigned_t amount, f_number_unsignedss_t *lengthss);
+ extern f_status_t f_number_unsignedss_decrease_by(const f_number_unsigned_t amount, f_number_unsignedss_t * const lengthss);
#endif // _di_f_number_unsignedss_decrease_by_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_number_unsignedss_increase_
- extern f_status_t f_number_unsignedss_increase(const f_number_unsigned_t step, f_number_unsignedss_t *lengthss);
+ extern f_status_t f_number_unsignedss_increase(const f_number_unsigned_t step, f_number_unsignedss_t * const lengthss);
#endif // _di_f_number_unsignedss_increase_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_number_unsignedss_increase_by_
- extern f_status_t f_number_unsignedss_increase_by(const f_number_unsigned_t amount, f_number_unsignedss_t *lengthss);
+ extern f_status_t f_number_unsignedss_increase_by(const f_number_unsigned_t amount, f_number_unsignedss_t * const lengthss);
#endif // _di_f_number_unsignedss_increase_by_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_number_unsignedss_resize_
- extern f_status_t f_number_unsignedss_resize(const f_number_unsigned_t length, f_number_unsignedss_t *lengthss);
+ extern f_status_t f_number_unsignedss_resize(const f_number_unsigned_t length, f_number_unsignedss_t * const lengthss);
#endif // _di_f_number_unsignedss_resize_
#ifdef __cplusplus
#endif
#ifndef _di_f_polls_adjust_
- f_status_t f_polls_adjust(const f_number_unsigned_t length, f_polls_t *polls) {
+ f_status_t f_polls_adjust(const f_number_unsigned_t length, f_polls_t * const polls) {
#ifndef _di_level_0_parameter_checking_
if (!polls) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_polls_adjust_
#ifndef _di_f_polls_append_
- f_status_t f_polls_append(const f_poll_t source, f_polls_t *destination) {
+ f_status_t f_polls_append(const f_poll_t source, f_polls_t * const destination) {
#ifndef _di_level_0_parameter_checking_
if (!destination) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_polls_append_
#ifndef _di_f_polls_append_all_
- f_status_t f_polls_append_all(const f_polls_t source, f_polls_t *destination) {
+ f_status_t f_polls_append_all(const f_polls_t source, f_polls_t * const destination) {
#ifndef _di_level_0_parameter_checking_
if (!destination) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_polls_append_all_
#ifndef _di_f_polls_decimate_by_
- f_status_t f_polls_decimate_by(const f_number_unsigned_t amount, f_polls_t *polls) {
+ f_status_t f_polls_decimate_by(const f_number_unsigned_t amount, f_polls_t * const polls) {
#ifndef _di_level_0_parameter_checking_
if (!polls) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_polls_decimate_by_
#ifndef _di_f_polls_decrease_by_
- f_status_t f_polls_decrease_by(const f_number_unsigned_t amount, f_polls_t *polls) {
+ f_status_t f_polls_decrease_by(const f_number_unsigned_t amount, f_polls_t * const polls) {
#ifndef _di_level_0_parameter_checking_
if (!polls) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_polls_decrease_by_
#ifndef _di_f_polls_increase_
- f_status_t f_polls_increase(const f_number_unsigned_t step, f_polls_t *polls) {
+ f_status_t f_polls_increase(const f_number_unsigned_t step, f_polls_t * const polls) {
#ifndef _di_level_0_parameter_checking_
if (!polls) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_polls_increase_
#ifndef _di_f_polls_increase_by_
- f_status_t f_polls_increase_by(const f_number_unsigned_t amount, f_polls_t *polls) {
+ f_status_t f_polls_increase_by(const f_number_unsigned_t amount, f_polls_t * const polls) {
#ifndef _di_level_0_parameter_checking_
if (!polls) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_polls_increase_by_
#ifndef _di_f_polls_resize_
- f_status_t f_polls_resize(const f_number_unsigned_t length, f_polls_t *polls) {
+ f_status_t f_polls_resize(const f_number_unsigned_t length, f_polls_t * const polls) {
#ifndef _di_level_0_parameter_checking_
if (!polls) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_polls_resize_
#ifndef _di_f_pollss_adjust_
- f_status_t f_pollss_adjust(const f_number_unsigned_t length, f_pollss_t *pollss) {
+ f_status_t f_pollss_adjust(const f_number_unsigned_t length, f_pollss_t * const pollss) {
#ifndef _di_level_0_parameter_checking_
if (!pollss) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_pollss_adjust_
#ifndef _di_f_pollss_append_
- f_status_t f_pollss_append(const f_polls_t source, f_pollss_t *destination) {
+ f_status_t f_pollss_append(const f_polls_t source, f_pollss_t * const destination) {
#ifndef _di_level_0_parameter_checking_
if (!destination) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_pollss_append_
#ifndef _di_f_pollss_append_all_
- f_status_t f_pollss_append_all(const f_pollss_t source, f_pollss_t *destination) {
+ f_status_t f_pollss_append_all(const f_pollss_t source, f_pollss_t * const destination) {
#ifndef _di_level_0_parameter_checking_
if (!destination) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_pollss_append_all_
#ifndef _di_f_pollss_decimate_by_
- f_status_t f_pollss_decimate_by(const f_number_unsigned_t amount, f_pollss_t *pollss) {
+ f_status_t f_pollss_decimate_by(const f_number_unsigned_t amount, f_pollss_t * const pollss) {
#ifndef _di_level_0_parameter_checking_
if (!pollss) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_pollss_decimate_by_
#ifndef _di_f_pollss_decrease_by_
- f_status_t f_pollss_decrease_by(const f_number_unsigned_t amount, f_pollss_t *pollss) {
+ f_status_t f_pollss_decrease_by(const f_number_unsigned_t amount, f_pollss_t * const pollss) {
#ifndef _di_level_0_parameter_checking_
if (!pollss) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_pollss_decrease_by_
#ifndef _di_f_pollss_increase_
- f_status_t f_pollss_increase(const f_number_unsigned_t step, f_pollss_t *pollss) {
+ f_status_t f_pollss_increase(const f_number_unsigned_t step, f_pollss_t * const pollss) {
#ifndef _di_level_0_parameter_checking_
if (!pollss) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_pollss_increase_
#ifndef _di_f_pollss_increase_by_
- f_status_t f_pollss_increase_by(const f_number_unsigned_t amount, f_pollss_t *pollss) {
+ f_status_t f_pollss_increase_by(const f_number_unsigned_t amount, f_pollss_t * const pollss) {
#ifndef _di_level_0_parameter_checking_
if (!pollss) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_pollss_increase_by_
#ifndef _di_f_pollss_resize_
- f_status_t f_pollss_resize(const f_number_unsigned_t length, f_pollss_t *pollss) {
+ f_status_t f_pollss_resize(const f_number_unsigned_t length, f_pollss_t * const pollss) {
#ifndef _di_level_0_parameter_checking_
if (!pollss) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
* Errors (with error bit) from: f_memory_adjust().
*/
#ifndef _di_f_polls_adjust_
- extern f_status_t f_polls_adjust(const f_number_unsigned_t length, f_polls_t *polls);
+ extern f_status_t f_polls_adjust(const f_number_unsigned_t length, f_polls_t * const polls);
#endif // _di_f_polls_adjust_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_polls_append_
- extern f_status_t f_polls_append(const f_poll_t source, f_polls_t *destination);
+ extern f_status_t f_polls_append(const f_poll_t source, f_polls_t * const destination);
#endif // _di_f_polls_append_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_polls_append_all_
- extern f_status_t f_polls_append_all(const f_polls_t source, f_polls_t *destination);
+ extern f_status_t f_polls_append_all(const f_polls_t source, f_polls_t * const destination);
#endif // _di_f_polls_append_all_
/**
* Errors (with error bit) from: f_memory_adjust().
*/
#ifndef _di_f_polls_decimate_by_
- extern f_status_t f_polls_decimate_by(const f_number_unsigned_t amount, f_polls_t *polls);
+ extern f_status_t f_polls_decimate_by(const f_number_unsigned_t amount, f_polls_t * const polls);
#endif // _di_f_polls_decimate_by_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_polls_decrease_by_
- extern f_status_t f_polls_decrease_by(const f_number_unsigned_t amount, f_polls_t *polls);
+ extern f_status_t f_polls_decrease_by(const f_number_unsigned_t amount, f_polls_t * const polls);
#endif // _di_f_polls_decrease_by_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_polls_increase_
- extern f_status_t f_polls_increase(const f_number_unsigned_t step, f_polls_t *polls);
+ extern f_status_t f_polls_increase(const f_number_unsigned_t step, f_polls_t * const polls);
#endif // _di_f_polls_increase_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_polls_increase_by_
- extern f_status_t f_polls_increase_by(const f_number_unsigned_t amount, f_polls_t *polls);
+ extern f_status_t f_polls_increase_by(const f_number_unsigned_t amount, f_polls_t * const polls);
#endif // _di_f_polls_increase_by_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_polls_resize_
- extern f_status_t f_polls_resize(const f_number_unsigned_t length, f_polls_t *polls);
+ extern f_status_t f_polls_resize(const f_number_unsigned_t length, f_polls_t * const polls);
#endif // _di_f_polls_resize_
/**
* Errors (with error bit) from: f_memory_destroy().
*/
#ifndef _di_f_pollss_adjust_
- extern f_status_t f_pollss_adjust(const f_number_unsigned_t length, f_pollss_t *pollss);
+ extern f_status_t f_pollss_adjust(const f_number_unsigned_t length, f_pollss_t * const pollss);
#endif // _di_f_pollss_adjust_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_pollss_append_
- extern f_status_t f_pollss_append(const f_polls_t source, f_pollss_t *destination);
+ extern f_status_t f_pollss_append(const f_polls_t source, f_pollss_t * const destination);
#endif // _di_f_pollss_append_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_pollss_append_all_
- extern f_status_t f_pollss_append_all(const f_pollss_t source, f_pollss_t *destination);
+ extern f_status_t f_pollss_append_all(const f_pollss_t source, f_pollss_t * const destination);
#endif // _di_f_pollss_append_all_
/**
* Errors (with error bit) from: f_memory_destroy().
*/
#ifndef _di_f_pollss_decimate_by_
- extern f_status_t f_pollss_decimate_by(const f_number_unsigned_t amount, f_pollss_t *pollss);
+ extern f_status_t f_pollss_decimate_by(const f_number_unsigned_t amount, f_pollss_t * const pollss);
#endif // _di_f_pollss_decimate_by_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_pollss_decrease_by_
- extern f_status_t f_pollss_decrease_by(const f_number_unsigned_t amount, f_pollss_t *pollss);
+ extern f_status_t f_pollss_decrease_by(const f_number_unsigned_t amount, f_pollss_t * const pollss);
#endif // _di_f_pollss_decrease_by_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_pollss_increase_
- extern f_status_t f_pollss_increase(const f_number_unsigned_t step, f_pollss_t *pollss);
+ extern f_status_t f_pollss_increase(const f_number_unsigned_t step, f_pollss_t * const pollss);
#endif // _di_f_pollss_increase_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_pollss_increase_by_
- extern f_status_t f_pollss_increase_by(const f_number_unsigned_t amount, f_pollss_t *pollss);
+ extern f_status_t f_pollss_increase_by(const f_number_unsigned_t amount, f_pollss_t * const pollss);
#endif // _di_f_pollss_increase_by_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_pollss_resize_
- extern f_status_t f_pollss_resize(const f_number_unsigned_t length, f_pollss_t *pollss);
+ extern f_status_t f_pollss_resize(const f_number_unsigned_t length, f_pollss_t * const pollss);
#endif // _di_f_pollss_resize_
#ifdef __cplusplus
#endif
#if !defined(_di_f_cells_adjust_) || !defined(_di_f_cells_decimate_by_)
- f_status_t private_f_cells_adjust(const f_number_unsigned_t length, f_cells_t *cells) {
+ f_status_t private_f_cells_adjust(const f_number_unsigned_t length, f_cells_t * const cells) {
const f_status_t status = f_memory_adjust(cells->size, length, sizeof(f_cell_t), (void **) & cells->array);
if (F_status_is_error(status)) return status;
#endif // !defined(_di_f_cells_adjust_) || !defined(_di_f_cells_decimate_by_)
#if !defined(_di_f_cells_append_) || !defined(_di_f_cellss_append_)
- extern f_status_t private_f_cells_append(const f_cell_t source, f_cells_t *destination) {
+ extern f_status_t private_f_cells_append(const f_cell_t source, f_cells_t * const destination) {
if (destination->used + 1 > destination->size) {
const f_status_t status = private_f_cells_resize(destination->used + F_memory_default_allocation_small_d, destination);
#endif // !defined(_di_f_cells_append_) || !defined(_di_f_cellss_append_)
#if !defined(_di_f_cells_append_) || !defined(_di_f_cells_append_all_) || !defined(_di_f_cellss_append_all_)
- extern f_status_t private_f_cells_append_all(const f_cells_t source, f_cells_t *destination) {
+ extern f_status_t private_f_cells_append_all(const f_cells_t source, f_cells_t * const destination) {
if (destination->used + source.used > destination->size) {
const f_status_t status = private_f_cells_resize(destination->used + source.used, destination);
#endif // !defined(_di_f_cells_append_) || !defined(_di_f_cells_append_all_) || !defined(_di_f_cellss_append_all_)
#if !defined(_di_f_cells_resize_) || !defined(_di_f_cells_append_) || !defined(_di_f_cells_decrease_by_) || !defined(_di_f_cellss_append_)
- f_status_t private_f_cells_resize(const f_number_unsigned_t length, f_cells_t *cells) {
+ f_status_t private_f_cells_resize(const f_number_unsigned_t length, f_cells_t * const cells) {
const f_status_t status = f_memory_resize(cells->size, length, sizeof(f_cell_t), (void **) & cells->array);
if (F_status_is_error(status)) return status;
#endif // !defined(_di_f_cells_resize_) || !defined(_di_f_cells_append_) || !defined(_di_f_cells_decrease_by_) || !defined(_di_f_cellss_append_)
#if !defined(_di_f_cellss_adjust_) || !defined(_di_f_cellss_decimate_by_)
- f_status_t private_f_cellss_adjust(const f_number_unsigned_t length, f_cellss_t *cellss) {
+ f_status_t private_f_cellss_adjust(const f_number_unsigned_t length, f_cellss_t * const cellss) {
f_status_t status = F_none;
#endif // !defined(_di_f_cellss_adjust_) || !defined(_di_f_cellss_decimate_by_)
#if !defined(_di_f_cellss_decrease_by_) || !defined(_di_f_cellss_increase_) || !defined(_di_f_cellss_increase_by_) || !defined(_di_f_cellss_resize_)
- f_status_t private_f_cellss_resize(const f_number_unsigned_t length, f_cellss_t *cellss) {
+ f_status_t private_f_cellss_resize(const f_number_unsigned_t length, f_cellss_t * const cellss) {
f_status_t status = F_none;
* @see f_cells_decimate_by()
*/
#if !defined(_di_f_cells_adjust_) || !defined(_di_f_cells_decimate_by_)
- extern f_status_t private_f_cells_adjust(const f_number_unsigned_t length, f_cells_t *cells) F_attribute_visibility_internal_d;
+ extern f_status_t private_f_cells_adjust(const f_number_unsigned_t length, f_cells_t * const cells) F_attribute_visibility_internal_d;
#endif // !defined(_di_f_cells_adjust_) || !defined(_di_f_cells_decimate_by_)
/**
* @see f_cellss_append()
*/
#if !defined(_di_f_cells_append_) || !defined(_di_f_cellss_append_)
- extern f_status_t private_f_cells_append(const f_cell_t source, f_cells_t *destination) F_attribute_visibility_internal_d;
+ extern f_status_t private_f_cells_append(const f_cell_t source, f_cells_t * const destination) F_attribute_visibility_internal_d;
#endif // !defined(_di_f_cells_append_) || !defined(_di_f_cellss_append_)
/**
* @see f_cellss_append_all()
*/
#if !defined(_di_f_cells_append_) || !defined(_di_f_cells_append_all_) || !defined(_di_f_cellss_append_all_)
- extern f_status_t private_f_cells_append_all(const f_cells_t source, f_cells_t *destination) F_attribute_visibility_internal_d;
+ extern f_status_t private_f_cells_append_all(const f_cells_t source, f_cells_t * const destination) F_attribute_visibility_internal_d;
#endif // !defined(_di_f_cells_append_) || !defined(_di_f_cells_append_all_) || !defined(_di_f_cellss_append_all_)
/**
* @see f_cellss_append()
*/
#if !defined(_di_f_cells_resize_) || !defined(_di_f_cells_append_) || !defined(_di_f_cells_decrease_by_) || !defined(_di_f_cellss_append_)
- extern f_status_t private_f_cells_resize(const f_number_unsigned_t length, f_cells_t *cells) F_attribute_visibility_internal_d;
+ extern f_status_t private_f_cells_resize(const f_number_unsigned_t length, f_cells_t * const cells) F_attribute_visibility_internal_d;
#endif // !defined(_di_f_cells_resize_) || !defined(_di_f_cells_append_) || !defined(_di_f_cells_decrease_by_) || !defined(_di_f_cellss_append_)
/**
* @see f_cellss_decimate_by()
*/
#if !defined(_di_f_cellss_adjust_) || !defined(_di_f_cellss_decimate_by_)
- extern f_status_t private_f_cellss_adjust(const f_number_unsigned_t length, f_cellss_t *cellss) F_attribute_visibility_internal_d;
+ extern f_status_t private_f_cellss_adjust(const f_number_unsigned_t length, f_cellss_t * const cellss) F_attribute_visibility_internal_d;
#endif // !defined(_di_f_cellss_adjust_) || !defined(_di_f_cellss_decimate_by_)
/**
* @see f_cellss_resize()
*/
#if !defined(_di_f_cellss_decrease_by_) || !defined(_di_f_cellss_increase_) || !defined(_di_f_cellss_increase_by_) || !defined(_di_f_cellss_resize_)
- extern f_status_t private_f_cellss_resize(const f_number_unsigned_t length, f_cellss_t *cellss) F_attribute_visibility_internal_d;
+ extern f_status_t private_f_cellss_resize(const f_number_unsigned_t length, f_cellss_t * const cellss) F_attribute_visibility_internal_d;
#endif // !defined(_di_f_cellss_decrease_by_) || !defined(_di_f_cellss_increase_) || !defined(_di_f_cellss_increase_by_) || !defined(_di_f_cellss_resize_)
#ifdef __cplusplus
#endif
#if !defined(_di_f_files_adjust_) || !defined(_di_f_files_decimate_by_)
- f_status_t private_f_files_adjust(const f_number_unsigned_t length, f_files_t *files) {
+ f_status_t private_f_files_adjust(const f_number_unsigned_t length, f_files_t * const files) {
const f_status_t status = f_memory_adjust(files->size, length, sizeof(f_file_t), (void **) & files->array);
if (F_status_is_error(status)) return status;
#endif // !defined(_di_f_files_adjust_) || !defined(_di_f_files_decimate_by_)
#if !defined(_di_f_files_append_) || !defined(_di_f_filess_append_)
- extern f_status_t private_f_files_append(const f_file_t source, f_files_t *destination) {
+ extern f_status_t private_f_files_append(const f_file_t source, f_files_t * const destination) {
if (destination->used + 1 > destination->size) {
const f_status_t status = private_f_files_resize(destination->used + F_memory_default_allocation_small_d, destination);
#endif // !defined(_di_f_files_append_) || !defined(_di_f_filess_append_)
#if !defined(_di_f_files_append_) || !defined(_di_f_files_append_all_) || !defined(_di_f_filess_append_all_)
- extern f_status_t private_f_files_append_all(const f_files_t source, f_files_t *destination) {
+ extern f_status_t private_f_files_append_all(const f_files_t source, f_files_t * const destination) {
if (destination->used + source.used > destination->size) {
const f_status_t status = private_f_files_resize(destination->used + source.used, destination);
#endif // !defined(_di_f_files_append_) || !defined(_di_f_files_append_all_) || !defined(_di_f_filess_append_all_)
#if !defined(_di_f_files_append_) || !defined(_di_f_files_append_all_) || !defined(_di_f_files_decrease_by_) || !defined(_di_f_files_increase_) || !defined(_di_f_files_increase_by_) || !defined(_di_f_files_resize_) || !defined(_di_f_filess_append_) || !defined(_di_f_filess_append_all_)
- f_status_t private_f_files_resize(const f_number_unsigned_t length, f_files_t *files) {
+ f_status_t private_f_files_resize(const f_number_unsigned_t length, f_files_t * const files) {
const f_status_t status = f_memory_resize(files->size, length, sizeof(f_file_t), (void **) & files->array);
if (F_status_is_error(status)) return status;
#endif // !defined(_di_f_files_append_) || !defined(_di_f_files_append_all_) || !defined(_di_f_files_decrease_by_) || !defined(_di_f_files_increase_) || !defined(_di_f_files_increase_by_) || !defined(_di_f_files_resize_) || !defined(_di_f_filess_append_) || !defined(_di_f_filess_append_all_)
#if !defined(_di_f_filess_adjust_) || !defined(_di_f_filess_decimate_by_)
- f_status_t private_f_filess_adjust(const f_number_unsigned_t length, f_filess_t *filess) {
+ f_status_t private_f_filess_adjust(const f_number_unsigned_t length, f_filess_t * const filess) {
f_status_t status = F_none;
#endif // !defined(_di_f_filess_adjust_) || !defined(_di_f_filess_decimate_by_)
#if !defined(_di_f_filess_decrease_by_) || !defined(_di_f_filess_increase_) || !defined(_di_f_filess_increase_by_) || !defined(_di_f_filess_resize_)
- f_status_t private_f_filess_resize(const f_number_unsigned_t length, f_filess_t *filess) {
+ f_status_t private_f_filess_resize(const f_number_unsigned_t length, f_filess_t * const filess) {
f_status_t status = F_none;
* @see f_files_decimate_by()
*/
#if !defined(_di_f_files_adjust_) || !defined(_di_f_files_decimate_by_)
- extern f_status_t private_f_files_adjust(const f_number_unsigned_t length, f_files_t *files) F_attribute_visibility_internal_d;
+ extern f_status_t private_f_files_adjust(const f_number_unsigned_t length, f_files_t * const files) F_attribute_visibility_internal_d;
#endif // !defined(_di_f_files_adjust_) || !defined(_di_f_files_decimate_by_)
/**
* @see f_filess_append()
*/
#if !defined(_di_f_files_append_) || !defined(_di_f_filess_append_)
- extern f_status_t private_f_files_append(const f_file_t source, f_files_t *destination) F_attribute_visibility_internal_d;
+ extern f_status_t private_f_files_append(const f_file_t source, f_files_t * const destination) F_attribute_visibility_internal_d;
#endif // !defined(_di_f_files_append_) || !defined(_di_f_filess_append_)
/**
* @see f_filess_append_all()
*/
#if !defined(_di_f_files_append_) || !defined(_di_f_files_append_all_) || !defined(_di_f_filess_append_all_)
- extern f_status_t private_f_files_append_all(const f_files_t source, f_files_t *destination) F_attribute_visibility_internal_d;
+ extern f_status_t private_f_files_append_all(const f_files_t source, f_files_t * const destination) F_attribute_visibility_internal_d;
#endif // !defined(_di_f_files_append_) || !defined(_di_f_files_append_all_) || !defined(_di_f_filess_append_all_)
/**
*
*/
#if !defined(_di_f_files_append_) || !defined(_di_f_files_append_all_) || !defined(_di_f_files_decrease_by_) || !defined(_di_f_files_increase_) || !defined(_di_f_files_increase_by_) || !defined(_di_f_files_resize_) || !defined(_di_f_filess_append_) || !defined(_di_f_filess_append_all_)
- extern f_status_t private_f_files_resize(const f_number_unsigned_t length, f_files_t *files) F_attribute_visibility_internal_d;
+ extern f_status_t private_f_files_resize(const f_number_unsigned_t length, f_files_t * const files) F_attribute_visibility_internal_d;
#endif // !defined(_di_f_files_append_) || !defined(_di_f_files_append_all_) || !defined(_di_f_files_decrease_by_) || !defined(_di_f_files_increase_) || !defined(_di_f_files_increase_by_) || !defined(_di_f_files_resize_) || !defined(_di_f_filess_append_) || !defined(_di_f_filess_append_all_)
/**
* @see f_filess_decimate_by()
*/
#if !defined(_di_f_filess_adjust_) || !defined(_di_f_filess_decimate_by_)
- extern f_status_t private_f_filess_adjust(const f_number_unsigned_t length, f_filess_t *filess) F_attribute_visibility_internal_d;
+ extern f_status_t private_f_filess_adjust(const f_number_unsigned_t length, f_filess_t * const filess) F_attribute_visibility_internal_d;
#endif // !defined(_di_f_filess_adjust_) || !defined(_di_f_filess_decimate_by_)
/**
* @see f_filess_resize()
*/
#if !defined(_di_f_filess_decrease_by_) || !defined(_di_f_filess_increase_) || !defined(_di_f_filess_increase_by_) || !defined(_di_f_filess_resize_)
- extern f_status_t private_f_filess_resize(const f_number_unsigned_t length, f_filess_t *filess) F_attribute_visibility_internal_d;
+ extern f_status_t private_f_filess_resize(const f_number_unsigned_t length, f_filess_t * const filess) F_attribute_visibility_internal_d;
#endif // !defined(_di_f_filess_decrease_by_) || !defined(_di_f_filess_increase_) || !defined(_di_f_filess_increase_by_) || !defined(_di_f_filess_resize_)
#ifdef __cplusplus
#endif
#if !defined(_di_f_fll_ids_adjust_) || !defined(_di_f_fll_ids_decimate_by_)
- f_status_t private_f_fll_ids_adjust(const f_number_unsigned_t length, f_fll_ids_t *ids) {
+ f_status_t private_f_fll_ids_adjust(const f_number_unsigned_t length, f_fll_ids_t * const ids) {
const f_status_t status = f_memory_adjust(ids->size, length, sizeof(f_fll_id_t), (void **) & ids->array);
if (F_status_is_error(status)) return status;
#endif // !defined(_di_f_fll_ids_adjust_) || !defined(_di_f_fll_ids_decimate_by_)
#if !defined(_di_f_fll_ids_append_) || !defined(_di_f_fll_idss_append_)
- extern f_status_t private_f_fll_ids_append(const f_fll_id_t source, f_fll_ids_t *destination) {
+ extern f_status_t private_f_fll_ids_append(const f_fll_id_t source, f_fll_ids_t * const destination) {
if (destination->used + 1 > destination->size) {
const f_status_t status = private_f_fll_ids_resize(destination->used + F_memory_default_allocation_small_d, destination);
#endif // !defined(_di_f_fll_ids_append_) || !defined(_di_f_fll_idss_append_)
#if !defined(_di_f_fll_ids_append_) || !defined(_di_f_fll_ids_append_all_) || !defined(_di_f_fll_idss_append_all_)
- extern f_status_t private_f_fll_ids_append_all(const f_fll_ids_t source, f_fll_ids_t *destination) {
+ extern f_status_t private_f_fll_ids_append_all(const f_fll_ids_t source, f_fll_ids_t * const destination) {
if (destination->used + source.used > destination->size) {
const f_status_t status = private_f_fll_ids_resize(destination->used + source.used, destination);
#endif // !defined(_di_f_fll_ids_append_) || !defined(_di_f_fll_ids_append_all_) || !defined(_di_f_fll_idss_append_all_)
#if !defined(_di_f_fll_ids_resize_) || !defined(_di_f_fll_ids_append_) || !defined(_di_f_fll_ids_decrease_by_) || !defined(_di_f_fll_idss_append_)
- f_status_t private_f_fll_ids_resize(const f_number_unsigned_t length, f_fll_ids_t *ids) {
+ f_status_t private_f_fll_ids_resize(const f_number_unsigned_t length, f_fll_ids_t * const ids) {
const f_status_t status = f_memory_resize(ids->size, length, sizeof(f_fll_id_t), (void **) & ids->array);
if (F_status_is_error(status)) return status;
#endif // !defined(_di_f_fll_ids_resize_) || !defined(_di_f_fll_ids_append_) || !defined(_di_f_fll_ids_decrease_by_) || !defined(_di_f_fll_idss_append_)
#if !defined(_di_f_fll_idss_adjust_) || !defined(_di_f_fll_idss_decimate_by_)
- f_status_t private_f_fll_idss_adjust(const f_number_unsigned_t length, f_fll_idss_t *idss) {
+ f_status_t private_f_fll_idss_adjust(const f_number_unsigned_t length, f_fll_idss_t * const idss) {
f_status_t status = F_none;
#endif // !defined(_di_f_fll_idss_adjust_) || !defined(_di_f_fll_idss_decimate_by_)
#if !defined(_di_f_fll_idss_decrease_by_) || !defined(_di_f_fll_idss_increase_) || !defined(_di_f_fll_idss_increase_by_) || !defined(_di_f_fll_idss_resize_)
- f_status_t private_f_fll_idss_resize(const f_number_unsigned_t length, f_fll_idss_t *idss) {
+ f_status_t private_f_fll_idss_resize(const f_number_unsigned_t length, f_fll_idss_t * const idss) {
f_status_t status = F_none;
* @see f_fll_ids_decimate_by()
*/
#if !defined(_di_f_fll_ids_adjust_) || !defined(_di_f_fll_ids_decimate_by_)
- extern f_status_t private_f_fll_ids_adjust(const f_number_unsigned_t length, f_fll_ids_t *fll_ids) F_attribute_visibility_internal_d;
+ extern f_status_t private_f_fll_ids_adjust(const f_number_unsigned_t length, f_fll_ids_t * const fll_ids) F_attribute_visibility_internal_d;
#endif // !defined(_di_f_fll_ids_adjust_) || !defined(_di_f_fll_ids_decimate_by_)
/**
* @see f_fll_idss_append()
*/
#if !defined(_di_f_fll_ids_append_) || !defined(_di_f_fll_idss_append_)
- extern f_status_t private_f_fll_ids_append(const f_fll_id_t source, f_fll_ids_t *destination) F_attribute_visibility_internal_d;
+ extern f_status_t private_f_fll_ids_append(const f_fll_id_t source, f_fll_ids_t * const destination) F_attribute_visibility_internal_d;
#endif // !defined(_di_f_fll_ids_append_) || !defined(_di_f_fll_idss_append_)
/**
* @see f_fll_idss_append_all()
*/
#if !defined(_di_f_fll_ids_append_) || !defined(_di_f_fll_ids_append_all_) || !defined(_di_f_fll_idss_append_all_)
- extern f_status_t private_f_fll_ids_append_all(const f_fll_ids_t source, f_fll_ids_t *destination) F_attribute_visibility_internal_d;
+ extern f_status_t private_f_fll_ids_append_all(const f_fll_ids_t source, f_fll_ids_t * const destination) F_attribute_visibility_internal_d;
#endif // !defined(_di_f_fll_ids_append_) || !defined(_di_f_fll_ids_append_all_) || !defined(_di_f_fll_idss_append_all_)
/**
* @see f_fll_idss_append()
*/
#if !defined(_di_f_fll_ids_resize_) || !defined(_di_f_fll_ids_append_) || !defined(_di_f_fll_ids_decrease_by_) || !defined(_di_f_fll_idss_append_)
- extern f_status_t private_f_fll_ids_resize(const f_number_unsigned_t length, f_fll_ids_t *fll_ids) F_attribute_visibility_internal_d;
+ extern f_status_t private_f_fll_ids_resize(const f_number_unsigned_t length, f_fll_ids_t * const fll_ids) F_attribute_visibility_internal_d;
#endif // !defined(_di_f_fll_ids_resize_) || !defined(_di_f_fll_ids_append_) || !defined(_di_f_fll_ids_decrease_by_) || !defined(_di_f_fll_idss_append_)
/**
* @see f_fll_idss_decimate_by()
*/
#if !defined(_di_f_fll_idss_adjust_) || !defined(_di_f_fll_idss_decimate_by_)
- extern f_status_t private_f_fll_idss_adjust(const f_number_unsigned_t length, f_fll_idss_t *fll_idss) F_attribute_visibility_internal_d;
+ extern f_status_t private_f_fll_idss_adjust(const f_number_unsigned_t length, f_fll_idss_t * const fll_idss) F_attribute_visibility_internal_d;
#endif // !defined(_di_f_fll_idss_adjust_) || !defined(_di_f_fll_idss_decimate_by_)
/**
* @see f_fll_idss_resize()
*/
#if !defined(_di_f_fll_idss_decrease_by_) || !defined(_di_f_fll_idss_increase_) || !defined(_di_f_fll_idss_increase_by_) || !defined(_di_f_fll_idss_resize_)
- extern f_status_t private_f_fll_idss_resize(const f_number_unsigned_t length, f_fll_idss_t *fll_idss) F_attribute_visibility_internal_d;
+ extern f_status_t private_f_fll_idss_resize(const f_number_unsigned_t length, f_fll_idss_t * const fll_idss) F_attribute_visibility_internal_d;
#endif // !defined(_di_f_fll_idss_decrease_by_) || !defined(_di_f_fll_idss_increase_) || !defined(_di_f_fll_idss_increase_by_) || !defined(_di_f_fll_idss_resize_)
#ifdef __cplusplus
#endif
#if !defined(_di_f_int128s_adjust_) || !defined(_di_f_int128s_decimate_by_)
- f_status_t private_f_int128s_adjust(const f_number_unsigned_t length, f_int128s_t *int128s) {
+ f_status_t private_f_int128s_adjust(const f_number_unsigned_t length, f_int128s_t * const int128s) {
const f_status_t status = f_memory_adjust(int128s->size, length, sizeof(f_int128s_t), (void **) & int128s->array);
if (F_status_is_error(status)) return status;
#endif // !defined(_di_f_int128s_adjust_) || !defined(_di_f_int128s_decimate_by_)
#if !defined(_di_f_int128s_append_) || !defined(_di_f_int128ss_append_)
- extern f_status_t private_f_int128s_append(const int128_t source, f_int128s_t *destination) {
+ extern f_status_t private_f_int128s_append(const int128_t source, f_int128s_t * const destination) {
if (destination->used + 1 > destination->size) {
const f_status_t status = private_f_int128s_resize(destination->used + F_memory_default_allocation_small_d, destination);
#endif // !defined(_di_f_int128s_append_) || !defined(_di_f_int128ss_append_)
#if !defined(_di_f_int128s_append_) || !defined(_di_f_int128s_append_all_) || !defined(_di_f_int128ss_append_all_)
- extern f_status_t private_f_int128s_append_all(const f_int128s_t source, f_int128s_t *destination) {
+ extern f_status_t private_f_int128s_append_all(const f_int128s_t source, f_int128s_t * const destination) {
if (destination->used + source.used > destination->size) {
const f_status_t status = private_f_int128s_resize(destination->used + source.used, destination);
#endif // !defined(_di_f_int128s_append_) || !defined(_di_f_int128s_append_all_) || !defined(_di_f_int128ss_append_all_)
#if !defined(_di_f_int128s_resize_) || !defined(_di_f_int128s_append_) || !defined(_di_f_int128s_decrease_by_) || !defined(_di_f_int128ss_append_)
- f_status_t private_f_int128s_resize(const f_number_unsigned_t length, f_int128s_t *int128s) {
+ f_status_t private_f_int128s_resize(const f_number_unsigned_t length, f_int128s_t * const int128s) {
const f_status_t status = f_memory_resize(int128s->size, length, sizeof(f_int128s_t), (void **) & int128s->array);
if (F_status_is_error(status)) return status;
#endif // !defined(_di_f_int128s_resize_) || !defined(_di_f_int128s_append_) || !defined(_di_f_int128s_decrease_by_) || !defined(_di_f_int128ss_append_)
#if !defined(_di_f_int128ss_adjust_) || !defined(_di_f_int128ss_decimate_by_)
- f_status_t private_f_int128ss_adjust(const f_number_unsigned_t length, f_int128ss_t *int128ss) {
+ f_status_t private_f_int128ss_adjust(const f_number_unsigned_t length, f_int128ss_t * const int128ss) {
f_status_t status = F_none;
#endif // !defined(_di_f_int128ss_adjust_) || !defined(_di_f_int128ss_decimate_by_)
#if !defined(_di_f_int128ss_decrease_by_) || !defined(_di_f_int128ss_increase_) || !defined(_di_f_int128ss_increase_by_) || !defined(_di_f_int128ss_resize_)
- f_status_t private_f_int128ss_resize(const f_number_unsigned_t length, f_int128ss_t *int128ss) {
+ f_status_t private_f_int128ss_resize(const f_number_unsigned_t length, f_int128ss_t * const int128ss) {
f_status_t status = F_none;
* @see f_int128s_decimate_by()
*/
#if !defined(_di_f_int128s_adjust_) || !defined(_di_f_int128s_decimate_by_)
- extern f_status_t private_f_int128s_adjust(const f_number_unsigned_t length, f_int128s_t *int128s) F_attribute_visibility_internal_d;
+ extern f_status_t private_f_int128s_adjust(const f_number_unsigned_t length, f_int128s_t * const int128s) F_attribute_visibility_internal_d;
#endif // !defined(_di_f_int128s_adjust_) || !defined(_di_f_int128s_decimate_by_)
/**
* @see f_int128ss_append()
*/
#if !defined(_di_f_int128s_append_) || !defined(_di_f_int128ss_append_)
- extern f_status_t private_f_int128s_append(const int128_t source, f_int128s_t *destination) F_attribute_visibility_internal_d;
+ extern f_status_t private_f_int128s_append(const int128_t source, f_int128s_t * const destination) F_attribute_visibility_internal_d;
#endif // !defined(_di_f_int128s_append_) || !defined(_di_f_int128ss_append_)
/**
* @see f_int128ss_append_all()
*/
#if !defined(_di_f_int128s_append_) || !defined(_di_f_int128s_append_all_) || !defined(_di_f_int128ss_append_all_)
- extern f_status_t private_f_int128s_append_all(const f_int128s_t source, f_int128s_t *destination) F_attribute_visibility_internal_d;
+ extern f_status_t private_f_int128s_append_all(const f_int128s_t source, f_int128s_t * const destination) F_attribute_visibility_internal_d;
#endif // !defined(_di_f_int128s_append_) || !defined(_di_f_int128s_append_all_) || !defined(_di_f_int128ss_append_all_)
/**
* @see f_int128ss_append()
*/
#if !defined(_di_f_int128s_resize_) || !defined(_di_f_int128s_append_) || !defined(_di_f_int128s_decrease_by_) || !defined(_di_f_int128ss_append_)
- extern f_status_t private_f_int128s_resize(const f_number_unsigned_t length, f_int128s_t *int128s) F_attribute_visibility_internal_d;
+ extern f_status_t private_f_int128s_resize(const f_number_unsigned_t length, f_int128s_t * const int128s) F_attribute_visibility_internal_d;
#endif // !defined(_di_f_int128s_resize_) || !defined(_di_f_int128s_append_) || !defined(_di_f_int128s_decrease_by_) || !defined(_di_f_int128ss_append_)
/**
* @see f_int128ss_decimate_by()
*/
#if !defined(_di_f_int128ss_adjust_) || !defined(_di_f_int128ss_decimate_by_)
- extern f_status_t private_f_int128ss_adjust(const f_number_unsigned_t length, f_int128ss_t *int128ss) F_attribute_visibility_internal_d;
+ extern f_status_t private_f_int128ss_adjust(const f_number_unsigned_t length, f_int128ss_t * const int128ss) F_attribute_visibility_internal_d;
#endif // !defined(_di_f_int128ss_adjust_) || !defined(_di_f_int128ss_decimate_by_)
/**
* @see f_int128ss_resize()
*/
#if !defined(_di_f_int128ss_decrease_by_) || !defined(_di_f_int128ss_increase_) || !defined(_di_f_int128ss_increase_by_) || !defined(_di_f_int128ss_resize_)
- extern f_status_t private_f_int128ss_resize(const f_number_unsigned_t length, f_int128ss_t *int128ss) F_attribute_visibility_internal_d;
+ extern f_status_t private_f_int128ss_resize(const f_number_unsigned_t length, f_int128ss_t * const int128ss) F_attribute_visibility_internal_d;
#endif // !defined(_di_f_int128ss_decrease_by_) || !defined(_di_f_int128ss_increase_) || !defined(_di_f_int128ss_increase_by_) || !defined(_di_f_int128ss_resize_)
#ifdef __cplusplus
#endif
#if !defined(_di_f_int16s_adjust_) || !defined(_di_f_int16s_decimate_by_)
- f_status_t private_f_int16s_adjust(const f_number_unsigned_t length, f_int16s_t *int16s) {
+ f_status_t private_f_int16s_adjust(const f_number_unsigned_t length, f_int16s_t * const int16s) {
const f_status_t status = f_memory_adjust(int16s->size, length, sizeof(int16_t), (void **) & int16s->array);
if (F_status_is_error(status)) return status;
#endif // !defined(_di_f_int16s_adjust_) || !defined(_di_f_int16s_decimate_by_)
#if !defined(_di_f_int16s_append_) || !defined(_di_f_int16ss_append_)
- extern f_status_t private_f_int16s_append(const int16_t source, f_int16s_t *destination) {
+ extern f_status_t private_f_int16s_append(const int16_t source, f_int16s_t * const destination) {
if (destination->used + 1 > destination->size) {
const f_status_t status = private_f_int16s_resize(destination->used + F_memory_default_allocation_small_d, destination);
#endif // !defined(_di_f_int16s_append_) || !defined(_di_f_int16ss_append_)
#if !defined(_di_f_int16s_append_) || !defined(_di_f_int16s_append_all_) || !defined(_di_f_int16ss_append_all_)
- extern f_status_t private_f_int16s_append_all(const f_int16s_t source, f_int16s_t *destination) {
+ extern f_status_t private_f_int16s_append_all(const f_int16s_t source, f_int16s_t * const destination) {
if (destination->used + source.used > destination->size) {
const f_status_t status = private_f_int16s_resize(destination->used + source.used, destination);
#endif // !defined(_di_f_int16s_append_) || !defined(_di_f_int16s_append_all_) || !defined(_di_f_int16ss_append_all_)
#if !defined(_di_f_int16s_resize_) || !defined(_di_f_int16s_append_) || !defined(_di_f_int16s_decrease_by_) || !defined(_di_f_int16ss_append_)
- f_status_t private_f_int16s_resize(const f_number_unsigned_t length, f_int16s_t *int16s) {
+ f_status_t private_f_int16s_resize(const f_number_unsigned_t length, f_int16s_t * const int16s) {
const f_status_t status = f_memory_resize(int16s->size, length, sizeof(int16_t), (void **) & int16s->array);
if (F_status_is_error(status)) return status;
#endif // !defined(_di_f_int16s_resize_) || !defined(_di_f_int16s_append_) || !defined(_di_f_int16s_decrease_by_) || !defined(_di_f_int16ss_append_)
#if !defined(_di_f_int16ss_adjust_) || !defined(_di_f_int16ss_decimate_by_)
- f_status_t private_f_int16ss_adjust(const f_number_unsigned_t length, f_int16ss_t *int16ss) {
+ f_status_t private_f_int16ss_adjust(const f_number_unsigned_t length, f_int16ss_t * const int16ss) {
f_status_t status = F_none;
#endif // !defined(_di_f_int16ss_adjust_) || !defined(_di_f_int16ss_decimate_by_)
#if !defined(_di_f_int16ss_decrease_by_) || !defined(_di_f_int16ss_increase_) || !defined(_di_f_int16ss_increase_by_) || !defined(_di_f_int16ss_resize_)
- f_status_t private_f_int16ss_resize(const f_number_unsigned_t length, f_int16ss_t *int16ss) {
+ f_status_t private_f_int16ss_resize(const f_number_unsigned_t length, f_int16ss_t * const int16ss) {
f_status_t status = F_none;
* @see f_int16s_decimate_by()
*/
#if !defined(_di_f_int16s_adjust_) || !defined(_di_f_int16s_decimate_by_)
- extern f_status_t private_f_int16s_adjust(const f_number_unsigned_t length, f_int16s_t *int16s) F_attribute_visibility_internal_d;
+ extern f_status_t private_f_int16s_adjust(const f_number_unsigned_t length, f_int16s_t * const int16s) F_attribute_visibility_internal_d;
#endif // !defined(_di_f_int16s_adjust_) || !defined(_di_f_int16s_decimate_by_)
/**
* @see f_int16ss_append()
*/
#if !defined(_di_f_int16s_append_) || !defined(_di_f_int16ss_append_)
- extern f_status_t private_f_int16s_append(const int16_t source, f_int16s_t *destination) F_attribute_visibility_internal_d;
+ extern f_status_t private_f_int16s_append(const int16_t source, f_int16s_t * const destination) F_attribute_visibility_internal_d;
#endif // !defined(_di_f_int16s_append_) || !defined(_di_f_int16ss_append_)
/**
* @see f_int16ss_append_all()
*/
#if !defined(_di_f_int16s_append_) || !defined(_di_f_int16s_append_all_) || !defined(_di_f_int16ss_append_all_)
- extern f_status_t private_f_int16s_append_all(const f_int16s_t source, f_int16s_t *destination) F_attribute_visibility_internal_d;
+ extern f_status_t private_f_int16s_append_all(const f_int16s_t source, f_int16s_t * const destination) F_attribute_visibility_internal_d;
#endif // !defined(_di_f_int16s_append_) || !defined(_di_f_int16s_append_all_) || !defined(_di_f_int16ss_append_all_)
/**
* @see f_int16ss_append()
*/
#if !defined(_di_f_int16s_resize_) || !defined(_di_f_int16s_append_) || !defined(_di_f_int16s_decrease_by_) || !defined(_di_f_int16ss_append_)
- extern f_status_t private_f_int16s_resize(const f_number_unsigned_t length, f_int16s_t *int16s) F_attribute_visibility_internal_d;
+ extern f_status_t private_f_int16s_resize(const f_number_unsigned_t length, f_int16s_t * const int16s) F_attribute_visibility_internal_d;
#endif // !defined(_di_f_int16s_resize_) || !defined(_di_f_int16s_append_) || !defined(_di_f_int16s_decrease_by_) || !defined(_di_f_int16ss_append_)
/**
* @see f_int16ss_decimate_by()
*/
#if !defined(_di_f_int16ss_adjust_) || !defined(_di_f_int16ss_decimate_by_)
- extern f_status_t private_f_int16ss_adjust(const f_number_unsigned_t length, f_int16ss_t *int16ss) F_attribute_visibility_internal_d;
+ extern f_status_t private_f_int16ss_adjust(const f_number_unsigned_t length, f_int16ss_t * const int16ss) F_attribute_visibility_internal_d;
#endif // !defined(_di_f_int16ss_adjust_) || !defined(_di_f_int16ss_decimate_by_)
/**
* @see f_int16ss_resize()
*/
#if !defined(_di_f_int16ss_decrease_by_) || !defined(_di_f_int16ss_increase_) || !defined(_di_f_int16ss_increase_by_) || !defined(_di_f_int16ss_resize_)
- extern f_status_t private_f_int16ss_resize(const f_number_unsigned_t length, f_int16ss_t *int16ss) F_attribute_visibility_internal_d;
+ extern f_status_t private_f_int16ss_resize(const f_number_unsigned_t length, f_int16ss_t * const int16ss) F_attribute_visibility_internal_d;
#endif // !defined(_di_f_int16ss_decrease_by_) || !defined(_di_f_int16ss_increase_) || !defined(_di_f_int16ss_increase_by_) || !defined(_di_f_int16ss_resize_)
#ifdef __cplusplus
#endif
#if !defined(_di_f_int32s_adjust_) || !defined(_di_f_int32s_decimate_by_)
- f_status_t private_f_int32s_adjust(const f_number_unsigned_t length, f_int32s_t *int32s) {
+ f_status_t private_f_int32s_adjust(const f_number_unsigned_t length, f_int32s_t * const int32s) {
const f_status_t status = f_memory_adjust(int32s->size, length, sizeof(int32_t), (void **) & int32s->array);
if (F_status_is_error(status)) return status;
#endif // !defined(_di_f_int32s_adjust_) || !defined(_di_f_int32s_decimate_by_)
#if !defined(_di_f_int32s_append_) || !defined(_di_f_int32ss_append_)
- extern f_status_t private_f_int32s_append(const int32_t source, f_int32s_t *destination) {
+ extern f_status_t private_f_int32s_append(const int32_t source, f_int32s_t * const destination) {
if (destination->used + 1 > destination->size) {
const f_status_t status = private_f_int32s_resize(destination->used + F_memory_default_allocation_small_d, destination);
#endif // !defined(_di_f_int32s_append_) || !defined(_di_f_int32ss_append_)
#if !defined(_di_f_int32s_append_) || !defined(_di_f_int32s_append_all_) || !defined(_di_f_int32ss_append_all_)
- extern f_status_t private_f_int32s_append_all(const f_int32s_t source, f_int32s_t *destination) {
+ extern f_status_t private_f_int32s_append_all(const f_int32s_t source, f_int32s_t * const destination) {
if (destination->used + source.used > destination->size) {
const f_status_t status = private_f_int32s_resize(destination->used + source.used, destination);
#endif // !defined(_di_f_int32s_append_) || !defined(_di_f_int32s_append_all_) || !defined(_di_f_int32ss_append_all_)
#if !defined(_di_f_int32s_resize_) || !defined(_di_f_int32s_append_) || !defined(_di_f_int32s_decrease_by_) || !defined(_di_f_int32ss_append_)
- f_status_t private_f_int32s_resize(const f_number_unsigned_t length, f_int32s_t *int32s) {
+ f_status_t private_f_int32s_resize(const f_number_unsigned_t length, f_int32s_t * const int32s) {
const f_status_t status = f_memory_resize(int32s->size, length, sizeof(int32_t), (void **) & int32s->array);
if (F_status_is_error(status)) return status;
#endif // !defined(_di_f_int32s_resize_) || !defined(_di_f_int32s_append_) || !defined(_di_f_int32s_decrease_by_) || !defined(_di_f_int32ss_append_)
#if !defined(_di_f_int32ss_adjust_) || !defined(_di_f_int32ss_decimate_by_)
- f_status_t private_f_int32ss_adjust(const f_number_unsigned_t length, f_int32ss_t *int32ss) {
+ f_status_t private_f_int32ss_adjust(const f_number_unsigned_t length, f_int32ss_t * const int32ss) {
f_status_t status = F_none;
#endif // !defined(_di_f_int32ss_adjust_) || !defined(_di_f_int32ss_decimate_by_)
#if !defined(_di_f_int32ss_decrease_by_) || !defined(_di_f_int32ss_increase_) || !defined(_di_f_int32ss_increase_by_) || !defined(_di_f_int32ss_resize_)
- f_status_t private_f_int32ss_resize(const f_number_unsigned_t length, f_int32ss_t *int32ss) {
+ f_status_t private_f_int32ss_resize(const f_number_unsigned_t length, f_int32ss_t * const int32ss) {
f_status_t status = F_none;
* @see f_int32s_decimate_by()
*/
#if !defined(_di_f_int32s_adjust_) || !defined(_di_f_int32s_decimate_by_)
- extern f_status_t private_f_int32s_adjust(const f_number_unsigned_t length, f_int32s_t *int32s) F_attribute_visibility_internal_d;
+ extern f_status_t private_f_int32s_adjust(const f_number_unsigned_t length, f_int32s_t * const int32s) F_attribute_visibility_internal_d;
#endif // !defined(_di_f_int32s_adjust_) || !defined(_di_f_int32s_decimate_by_)
/**
* @see f_int32ss_append()
*/
#if !defined(_di_f_int32s_append_) || !defined(_di_f_int32ss_append_)
- extern f_status_t private_f_int32s_append(const int32_t source, f_int32s_t *destination) F_attribute_visibility_internal_d;
+ extern f_status_t private_f_int32s_append(const int32_t source, f_int32s_t * const destination) F_attribute_visibility_internal_d;
#endif // !defined(_di_f_int32s_append_) || !defined(_di_f_int32ss_append_)
/**
* @see f_int32ss_append_all()
*/
#if !defined(_di_f_int32s_append_) || !defined(_di_f_int32s_append_all_) || !defined(_di_f_int32ss_append_all_)
- extern f_status_t private_f_int32s_append_all(const f_int32s_t source, f_int32s_t *destination) F_attribute_visibility_internal_d;
+ extern f_status_t private_f_int32s_append_all(const f_int32s_t source, f_int32s_t * const destination) F_attribute_visibility_internal_d;
#endif // !defined(_di_f_int32s_append_) || !defined(_di_f_int32s_append_all_) || !defined(_di_f_int32ss_append_all_)
/**
* @see f_int32ss_append()
*/
#if !defined(_di_f_int32s_resize_) || !defined(_di_f_int32s_append_) || !defined(_di_f_int32s_decrease_by_) || !defined(_di_f_int32ss_append_)
- extern f_status_t private_f_int32s_resize(const f_number_unsigned_t length, f_int32s_t *int32s) F_attribute_visibility_internal_d;
+ extern f_status_t private_f_int32s_resize(const f_number_unsigned_t length, f_int32s_t * const int32s) F_attribute_visibility_internal_d;
#endif // !defined(_di_f_int32s_resize_) || !defined(_di_f_int32s_append_) || !defined(_di_f_int32s_decrease_by_) || !defined(_di_f_int32ss_append_)
/**
* @see f_int32ss_decimate_by()
*/
#if !defined(_di_f_int32ss_adjust_) || !defined(_di_f_int32ss_decimate_by_)
- extern f_status_t private_f_int32ss_adjust(const f_number_unsigned_t length, f_int32ss_t *int32ss) F_attribute_visibility_internal_d;
+ extern f_status_t private_f_int32ss_adjust(const f_number_unsigned_t length, f_int32ss_t * const int32ss) F_attribute_visibility_internal_d;
#endif // !defined(_di_f_int32ss_adjust_) || !defined(_di_f_int32ss_decimate_by_)
/**
* @see f_int32ss_resize()
*/
#if !defined(_di_f_int32ss_decrease_by_) || !defined(_di_f_int32ss_increase_) || !defined(_di_f_int32ss_increase_by_) || !defined(_di_f_int32ss_resize_)
- extern f_status_t private_f_int32ss_resize(const f_number_unsigned_t length, f_int32ss_t *int32ss) F_attribute_visibility_internal_d;
+ extern f_status_t private_f_int32ss_resize(const f_number_unsigned_t length, f_int32ss_t * const int32ss) F_attribute_visibility_internal_d;
#endif // !defined(_di_f_int32ss_decrease_by_) || !defined(_di_f_int32ss_increase_) || !defined(_di_f_int32ss_increase_by_) || !defined(_di_f_int32ss_resize_)
#ifdef __cplusplus
#endif
#if !defined(_di_f_int64s_adjust_) || !defined(_di_f_int64s_decimate_by_)
- f_status_t private_f_int64s_adjust(const f_number_unsigned_t length, f_int64s_t *int64s) {
+ f_status_t private_f_int64s_adjust(const f_number_unsigned_t length, f_int64s_t * const int64s) {
const f_status_t status = f_memory_adjust(int64s->size, length, sizeof(int64_t), (void **) & int64s->array);
if (F_status_is_error(status)) return status;
#endif // !defined(_di_f_int64s_adjust_) || !defined(_di_f_int64s_decimate_by_)
#if !defined(_di_f_int64s_append_) || !defined(_di_f_int64ss_append_)
- extern f_status_t private_f_int64s_append(const int64_t source, f_int64s_t *destination) {
+ extern f_status_t private_f_int64s_append(const int64_t source, f_int64s_t * const destination) {
if (destination->used + 1 > destination->size) {
const f_status_t status = private_f_int64s_resize(destination->used + F_memory_default_allocation_small_d, destination);
#endif // !defined(_di_f_int64s_append_) || !defined(_di_f_int64ss_append_)
#if !defined(_di_f_int64s_append_) || !defined(_di_f_int64s_append_all_) || !defined(_di_f_int64ss_append_all_)
- extern f_status_t private_f_int64s_append_all(const f_int64s_t source, f_int64s_t *destination) {
+ extern f_status_t private_f_int64s_append_all(const f_int64s_t source, f_int64s_t * const destination) {
if (destination->used + source.used > destination->size) {
const f_status_t status = private_f_int64s_resize(destination->used + source.used, destination);
#endif // !defined(_di_f_int64s_append_) || !defined(_di_f_int64s_append_all_) || !defined(_di_f_int64ss_append_all_)
#if !defined(_di_f_int64s_resize_) || !defined(_di_f_int64s_append_) || !defined(_di_f_int64s_decrease_by_) || !defined(_di_f_int64ss_append_)
- f_status_t private_f_int64s_resize(const f_number_unsigned_t length, f_int64s_t *int64s) {
+ f_status_t private_f_int64s_resize(const f_number_unsigned_t length, f_int64s_t * const int64s) {
const f_status_t status = f_memory_resize(int64s->size, length, sizeof(int64_t), (void **) & int64s->array);
if (F_status_is_error(status)) return status;
#endif // !defined(_di_f_int64s_resize_) || !defined(_di_f_int64s_append_) || !defined(_di_f_int64s_decrease_by_) || !defined(_di_f_int64ss_append_)
#if !defined(_di_f_int64ss_adjust_) || !defined(_di_f_int64ss_decimate_by_)
- f_status_t private_f_int64ss_adjust(const f_number_unsigned_t length, f_int64ss_t *int64ss) {
+ f_status_t private_f_int64ss_adjust(const f_number_unsigned_t length, f_int64ss_t * const int64ss) {
f_status_t status = F_none;
#endif // !defined(_di_f_int64ss_adjust_) || !defined(_di_f_int64ss_decimate_by_)
#if !defined(_di_f_int64ss_decrease_by_) || !defined(_di_f_int64ss_increase_) || !defined(_di_f_int64ss_increase_by_) || !defined(_di_f_int64ss_resize_)
- f_status_t private_f_int64ss_resize(const f_number_unsigned_t length, f_int64ss_t *int64ss) {
+ f_status_t private_f_int64ss_resize(const f_number_unsigned_t length, f_int64ss_t * const int64ss) {
f_status_t status = F_none;
* @see f_int64s_decimate_by()
*/
#if !defined(_di_f_int64s_adjust_) || !defined(_di_f_int64s_decimate_by_)
- extern f_status_t private_f_int64s_adjust(const f_number_unsigned_t length, f_int64s_t *int64s) F_attribute_visibility_internal_d;
+ extern f_status_t private_f_int64s_adjust(const f_number_unsigned_t length, f_int64s_t * const int64s) F_attribute_visibility_internal_d;
#endif // !defined(_di_f_int64s_adjust_) || !defined(_di_f_int64s_decimate_by_)
/**
* @see f_int64ss_append()
*/
#if !defined(_di_f_int64s_append_) || !defined(_di_f_int64ss_append_)
- extern f_status_t private_f_int64s_append(const int64_t source, f_int64s_t *destination) F_attribute_visibility_internal_d;
+ extern f_status_t private_f_int64s_append(const int64_t source, f_int64s_t * const destination) F_attribute_visibility_internal_d;
#endif // !defined(_di_f_int64s_append_) || !defined(_di_f_int64ss_append_)
/**
* @see f_int64ss_append_all()
*/
#if !defined(_di_f_int64s_append_) || !defined(_di_f_int64s_append_all_) || !defined(_di_f_int64ss_append_all_)
- extern f_status_t private_f_int64s_append_all(const f_int64s_t source, f_int64s_t *destination) F_attribute_visibility_internal_d;
+ extern f_status_t private_f_int64s_append_all(const f_int64s_t source, f_int64s_t * const destination) F_attribute_visibility_internal_d;
#endif // !defined(_di_f_int64s_append_) || !defined(_di_f_int64s_append_all_) || !defined(_di_f_int64ss_append_all_)
/**
* @see f_int64ss_append()
*/
#if !defined(_di_f_int64s_resize_) || !defined(_di_f_int64s_append_) || !defined(_di_f_int64s_decrease_by_) || !defined(_di_f_int64ss_append_)
- extern f_status_t private_f_int64s_resize(const f_number_unsigned_t length, f_int64s_t *int64s) F_attribute_visibility_internal_d;
+ extern f_status_t private_f_int64s_resize(const f_number_unsigned_t length, f_int64s_t * const int64s) F_attribute_visibility_internal_d;
#endif // !defined(_di_f_int64s_resize_) || !defined(_di_f_int64s_append_) || !defined(_di_f_int64s_decrease_by_) || !defined(_di_f_int64ss_append_)
/**
* @see f_int64ss_decimate_by()
*/
#if !defined(_di_f_int64ss_adjust_) || !defined(_di_f_int64ss_decimate_by_)
- extern f_status_t private_f_int64ss_adjust(const f_number_unsigned_t length, f_int64ss_t *int64ss) F_attribute_visibility_internal_d;
+ extern f_status_t private_f_int64ss_adjust(const f_number_unsigned_t length, f_int64ss_t * const int64ss) F_attribute_visibility_internal_d;
#endif // !defined(_di_f_int64ss_adjust_) || !defined(_di_f_int64ss_decimate_by_)
/**
* @see f_int64ss_resize()
*/
#if !defined(_di_f_int64ss_decrease_by_) || !defined(_di_f_int64ss_increase_) || !defined(_di_f_int64ss_increase_by_) || !defined(_di_f_int64ss_resize_)
- extern f_status_t private_f_int64ss_resize(const f_number_unsigned_t length, f_int64ss_t *int64ss) F_attribute_visibility_internal_d;
+ extern f_status_t private_f_int64ss_resize(const f_number_unsigned_t length, f_int64ss_t * const int64ss) F_attribute_visibility_internal_d;
#endif // !defined(_di_f_int64ss_decrease_by_) || !defined(_di_f_int64ss_increase_) || !defined(_di_f_int64ss_increase_by_) || !defined(_di_f_int64ss_resize_)
#ifdef __cplusplus
#endif
#if !defined(_di_f_int8s_adjust_) || !defined(_di_f_int8s_decimate_by_)
- f_status_t private_f_int8s_adjust(const f_number_unsigned_t length, f_int8s_t *int8s) {
+ f_status_t private_f_int8s_adjust(const f_number_unsigned_t length, f_int8s_t * const int8s) {
const f_status_t status = f_memory_adjust(int8s->size, length, sizeof(int8_t), (void **) & int8s->array);
if (F_status_is_error(status)) return status;
#endif // !defined(_di_f_int8s_adjust_) || !defined(_di_f_int8s_decimate_by_)
#if !defined(_di_f_int8s_append_) || !defined(_di_f_int8ss_append_)
- extern f_status_t private_f_int8s_append(const int8_t source, f_int8s_t *destination) {
+ extern f_status_t private_f_int8s_append(const int8_t source, f_int8s_t * const destination) {
if (destination->used + 1 > destination->size) {
const f_status_t status = private_f_int8s_resize(destination->used + F_memory_default_allocation_small_d, destination);
#endif // !defined(_di_f_int8s_append_) || !defined(_di_f_int8ss_append_)
#if !defined(_di_f_int8s_append_) || !defined(_di_f_int8s_append_all_) || !defined(_di_f_int8ss_append_all_)
- extern f_status_t private_f_int8s_append_all(const f_int8s_t source, f_int8s_t *destination) {
+ extern f_status_t private_f_int8s_append_all(const f_int8s_t source, f_int8s_t * const destination) {
if (destination->used + source.used > destination->size) {
const f_status_t status = private_f_int8s_resize(destination->used + source.used, destination);
#endif // !defined(_di_f_int8s_append_) || !defined(_di_f_int8s_append_all_) || !defined(_di_f_int8ss_append_all_)
#if !defined(_di_f_int8s_append_) || !defined(_di_f_int8s_append_all_) || !defined(_di_f_int8s_decrease_by_) || !defined(_di_f_int8s_increase_) || !defined(_di_f_int8s_increase_by_) || !defined(_di_f_int8s_resize_) || !defined(_di_f_int8ss_append_) || !defined(_di_f_int8ss_append_all_)
- f_status_t private_f_int8s_resize(const f_number_unsigned_t length, f_int8s_t *int8s) {
+ f_status_t private_f_int8s_resize(const f_number_unsigned_t length, f_int8s_t * const int8s) {
const f_status_t status = f_memory_resize(int8s->size, length, sizeof(int8_t), (void **) & int8s->array);
if (F_status_is_error(status)) return status;
#endif // !defined(_di_f_int8s_append_) || !defined(_di_f_int8s_append_all_) || !defined(_di_f_int8s_decrease_by_) || !defined(_di_f_int8s_increase_) || !defined(_di_f_int8s_increase_by_) || !defined(_di_f_int8s_resize_) || !defined(_di_f_int8ss_append_) || !defined(_di_f_int8ss_append_all_)
#if !defined(_di_f_int8ss_adjust_) || !defined(_di_f_int8ss_decimate_by_)
- f_status_t private_f_int8ss_adjust(const f_number_unsigned_t length, f_int8ss_t *int8ss) {
+ f_status_t private_f_int8ss_adjust(const f_number_unsigned_t length, f_int8ss_t * const int8ss) {
f_status_t status = F_none;
#endif // !defined(_di_f_int8ss_adjust_) || !defined(_di_f_int8ss_decimate_by_)
#if !defined(_di_f_int8ss_decrease_by_) || !defined(_di_f_int8ss_increase_) || !defined(_di_f_int8ss_increase_by_) || !defined(_di_f_int8ss_resize_)
- f_status_t private_f_int8ss_resize(const f_number_unsigned_t length, f_int8ss_t *int8ss) {
+ f_status_t private_f_int8ss_resize(const f_number_unsigned_t length, f_int8ss_t * const int8ss) {
f_status_t status = F_none;
* @see f_int8s_decimate_by()
*/
#if !defined(_di_f_int8s_adjust_) || !defined(_di_f_int8s_decimate_by_)
- extern f_status_t private_f_int8s_adjust(const f_number_unsigned_t length, f_int8s_t *int8s) F_attribute_visibility_internal_d;
+ extern f_status_t private_f_int8s_adjust(const f_number_unsigned_t length, f_int8s_t * const int8s) F_attribute_visibility_internal_d;
#endif // !defined(_di_f_int8s_adjust_) || !defined(_di_f_int8s_decimate_by_)
/**
* @see f_int8ss_append()
*/
#if !defined(_di_f_int8s_append_) || !defined(_di_f_int8ss_append_)
- extern f_status_t private_f_int8s_append(const int8_t source, f_int8s_t *destination) F_attribute_visibility_internal_d;
+ extern f_status_t private_f_int8s_append(const int8_t source, f_int8s_t * const destination) F_attribute_visibility_internal_d;
#endif // !defined(_di_f_int8s_append_) || !defined(_di_f_int8ss_append_)
/**
* @see f_int8ss_append_all()
*/
#if !defined(_di_f_int8s_append_) || !defined(_di_f_int8s_append_all_) || !defined(_di_f_int8ss_append_all_)
- extern f_status_t private_f_int8s_append_all(const f_int8s_t source, f_int8s_t *destination) F_attribute_visibility_internal_d;
+ extern f_status_t private_f_int8s_append_all(const f_int8s_t source, f_int8s_t * const destination) F_attribute_visibility_internal_d;
#endif // !defined(_di_f_int8s_append_) || !defined(_di_f_int8s_append_all_) || !defined(_di_f_int8ss_append_all_)
/**
*
*/
#if !defined(_di_f_int8s_append_) || !defined(_di_f_int8s_append_all_) || !defined(_di_f_int8s_decrease_by_) || !defined(_di_f_int8s_increase_) || !defined(_di_f_int8s_increase_by_) || !defined(_di_f_int8s_resize_) || !defined(_di_f_int8ss_append_) || !defined(_di_f_int8ss_append_all_)
- extern f_status_t private_f_int8s_resize(const f_number_unsigned_t length, f_int8s_t *int8s) F_attribute_visibility_internal_d;
+ extern f_status_t private_f_int8s_resize(const f_number_unsigned_t length, f_int8s_t * const int8s) F_attribute_visibility_internal_d;
#endif // !defined(_di_f_int8s_append_) || !defined(_di_f_int8s_append_all_) || !defined(_di_f_int8s_decrease_by_) || !defined(_di_f_int8s_increase_) || !defined(_di_f_int8s_increase_by_) || !defined(_di_f_int8s_resize_) || !defined(_di_f_int8ss_append_) || !defined(_di_f_int8ss_append_all_)
/**
* @see f_int8ss_decimate_by()
*/
#if !defined(_di_f_int8ss_adjust_) || !defined(_di_f_int8ss_decimate_by_)
- extern f_status_t private_f_int8ss_adjust(const f_number_unsigned_t length, f_int8ss_t *int8ss) F_attribute_visibility_internal_d;
+ extern f_status_t private_f_int8ss_adjust(const f_number_unsigned_t length, f_int8ss_t * const int8ss) F_attribute_visibility_internal_d;
#endif // !defined(_di_f_int8ss_adjust_) || !defined(_di_f_int8ss_decimate_by_)
/**
* @see f_int8ss_resize()
*/
#if !defined(_di_f_int8ss_decrease_by_) || !defined(_di_f_int8ss_increase_) || !defined(_di_f_int8ss_increase_by_) || !defined(_di_f_int8ss_resize_)
- extern f_status_t private_f_int8ss_resize(const f_number_unsigned_t length, f_int8ss_t *int8ss) F_attribute_visibility_internal_d;
+ extern f_status_t private_f_int8ss_resize(const f_number_unsigned_t length, f_int8ss_t * const int8ss) F_attribute_visibility_internal_d;
#endif // !defined(_di_f_int8ss_decrease_by_) || !defined(_di_f_int8ss_increase_) || !defined(_di_f_int8ss_increase_by_) || !defined(_di_f_int8ss_resize_)
#ifdef __cplusplus
#endif
#if !defined(_di_f_number_unsigneds_adjust_) || !defined(_di_f_number_unsigneds_decimate_by_)
- f_status_t private_f_number_unsigneds_adjust(const f_number_unsigned_t length, f_number_unsigneds_t *number_unsigneds) {
+ f_status_t private_f_number_unsigneds_adjust(const f_number_unsigned_t length, f_number_unsigneds_t * const number_unsigneds) {
const f_status_t status = f_memory_adjust(number_unsigneds->size, length, sizeof(f_number_unsigned_t), (void **) & number_unsigneds->array);
if (F_status_is_error(status)) return status;
#endif // !defined(_di_f_number_unsigneds_adjust_) || !defined(_di_f_number_unsigneds_decimate_by_)
#if !defined(_di_f_number_unsigneds_append_) || !defined(_di_f_number_unsignedss_append_)
- extern f_status_t private_f_number_unsigneds_append(const f_number_unsigned_t source, f_number_unsigneds_t *destination) {
+ extern f_status_t private_f_number_unsigneds_append(const f_number_unsigned_t source, f_number_unsigneds_t * const destination) {
if (destination->used + 1 > destination->size) {
const f_status_t status = private_f_number_unsigneds_resize(destination->used + F_memory_default_allocation_small_d, destination);
#endif // !defined(_di_f_number_unsigneds_append_) || !defined(_di_f_number_unsignedss_append_)
#if !defined(_di_f_number_unsigneds_append_) || !defined(_di_f_number_unsigneds_append_all_) || !defined(_di_f_number_unsignedss_append_all_)
- extern f_status_t private_f_number_unsigneds_append_all(const f_number_unsigneds_t source, f_number_unsigneds_t *destination) {
+ extern f_status_t private_f_number_unsigneds_append_all(const f_number_unsigneds_t source, f_number_unsigneds_t * const destination) {
if (destination->used + source.used > destination->size) {
const f_status_t status = private_f_number_unsigneds_resize(destination->used + source.used, destination);
#endif // !defined(_di_f_number_unsigneds_append_) || !defined(_di_f_number_unsigneds_append_all_) || !defined(_di_f_number_unsignedss_append_all_)
#if !defined(_di_f_number_unsigneds_resize_) || !defined(_di_f_number_unsigneds_append_) || !defined(_di_f_number_unsigneds_decrease_by_) || !defined(_di_f_number_unsignedss_append_)
- f_status_t private_f_number_unsigneds_resize(const f_number_unsigned_t length, f_number_unsigneds_t *lengths) {
+ f_status_t private_f_number_unsigneds_resize(const f_number_unsigned_t length, f_number_unsigneds_t * const lengths) {
const f_status_t status = f_memory_resize(lengths->size, length, sizeof(f_number_unsigned_t), (void **) & lengths->array);
if (F_status_is_error(status)) return status;
#endif // !defined(_di_f_number_unsigneds_resize_) || !defined(_di_f_number_unsigneds_append_) || !defined(_di_f_number_unsigneds_decrease_by_) || !defined(_di_f_number_unsignedss_append_)
#if !defined(_di_f_number_unsignedss_adjust_) || !defined(_di_f_number_unsignedss_decimate_by_)
- f_status_t private_f_number_unsignedss_adjust(const f_number_unsigned_t length, f_number_unsignedss_t *lengthss) {
+ f_status_t private_f_number_unsignedss_adjust(const f_number_unsigned_t length, f_number_unsignedss_t * const lengthss) {
f_status_t status = F_none;
#endif // !defined(_di_f_number_unsignedss_adjust_) || !defined(_di_f_number_unsignedss_decimate_by_)
#if !defined(_di_f_number_unsignedss_decrease_by_) || !defined(_di_f_number_unsignedss_increase_) || !defined(_di_f_number_unsignedss_increase_by_) || !defined(_di_f_number_unsignedss_resize_)
- f_status_t private_f_number_unsignedss_resize(const f_number_unsigned_t length, f_number_unsignedss_t *lengthss) {
+ f_status_t private_f_number_unsignedss_resize(const f_number_unsigned_t length, f_number_unsignedss_t * const lengthss) {
f_status_t status = F_none;
* @see f_number_unsigneds_decimate_by()
*/
#if !defined(_di_f_number_unsigneds_adjust_) || !defined(_di_f_number_unsigneds_decimate_by_)
- extern f_status_t private_f_number_unsigneds_adjust(const f_number_unsigned_t length, f_number_unsigneds_t *lengths) F_attribute_visibility_internal_d;
+ extern f_status_t private_f_number_unsigneds_adjust(const f_number_unsigned_t length, f_number_unsigneds_t * const lengths) F_attribute_visibility_internal_d;
#endif // !defined(_di_f_number_unsigneds_adjust_) || !defined(_di_f_number_unsigneds_decimate_by_)
/**
* @see f_number_unsignedss_append()
*/
#if !defined(_di_f_number_unsigneds_append_) || !defined(_di_f_number_unsignedss_append_)
- extern f_status_t private_f_number_unsigneds_append(const f_number_unsigned_t source, f_number_unsigneds_t *destination) F_attribute_visibility_internal_d;
+ extern f_status_t private_f_number_unsigneds_append(const f_number_unsigned_t source, f_number_unsigneds_t * const destination) F_attribute_visibility_internal_d;
#endif // !defined(_di_f_number_unsigneds_append_) || !defined(_di_f_number_unsignedss_append_)
/**
* @see f_number_unsignedss_append_all()
*/
#if !defined(_di_f_number_unsigneds_append_) || !defined(_di_f_number_unsigneds_append_all_) || !defined(_di_f_number_unsignedss_append_all_)
- extern f_status_t private_f_number_unsigneds_append_all(const f_number_unsigneds_t source, f_number_unsigneds_t *destination) F_attribute_visibility_internal_d;
+ extern f_status_t private_f_number_unsigneds_append_all(const f_number_unsigneds_t source, f_number_unsigneds_t * const destination) F_attribute_visibility_internal_d;
#endif // !defined(_di_f_number_unsigneds_append_) || !defined(_di_f_number_unsigneds_append_all_) || !defined(_di_f_number_unsignedss_append_all_)
/**
* @see f_number_unsignedss_append()
*/
#if !defined(_di_f_number_unsigneds_resize_) || !defined(_di_f_number_unsigneds_append_) || !defined(_di_f_number_unsigneds_decrease_by_) || !defined(_di_f_number_unsignedss_append_)
- extern f_status_t private_f_number_unsigneds_resize(const f_number_unsigned_t length, f_number_unsigneds_t *lengths) F_attribute_visibility_internal_d;
+ extern f_status_t private_f_number_unsigneds_resize(const f_number_unsigned_t length, f_number_unsigneds_t * const lengths) F_attribute_visibility_internal_d;
#endif // !defined(_di_f_number_unsigneds_resize_) || !defined(_di_f_number_unsigneds_append_) || !defined(_di_f_number_unsigneds_decrease_by_) || !defined(_di_f_number_unsignedss_append_)
/**
* @see f_number_unsignedss_decimate_by()
*/
#if !defined(_di_f_number_unsignedss_adjust_) || !defined(_di_f_number_unsignedss_decimate_by_)
- extern f_status_t private_f_number_unsignedss_adjust(const f_number_unsigned_t length, f_number_unsignedss_t *lengthss) F_attribute_visibility_internal_d;
+ extern f_status_t private_f_number_unsignedss_adjust(const f_number_unsigned_t length, f_number_unsignedss_t * const lengthss) F_attribute_visibility_internal_d;
#endif // !defined(_di_f_number_unsignedss_adjust_) || !defined(_di_f_number_unsignedss_decimate_by_)
/**
* @see f_number_unsignedss_resize()
*/
#if !defined(_di_f_number_unsignedss_decrease_by_) || !defined(_di_f_number_unsignedss_increase_) || !defined(_di_f_number_unsignedss_increase_by_) || !defined(_di_f_number_unsignedss_resize_)
- extern f_status_t private_f_number_unsignedss_resize(const f_number_unsigned_t length, f_number_unsignedss_t *lengthss) F_attribute_visibility_internal_d;
+ extern f_status_t private_f_number_unsignedss_resize(const f_number_unsigned_t length, f_number_unsignedss_t * const lengthss) F_attribute_visibility_internal_d;
#endif // !defined(_di_f_number_unsignedss_decrease_by_) || !defined(_di_f_number_unsignedss_increase_) || !defined(_di_f_number_unsignedss_increase_by_) || !defined(_di_f_number_unsignedss_resize_)
#ifdef __cplusplus
#endif
#if !defined(_di_f_polls_adjust_) || !defined(_di_f_polls_decimate_by_)
- f_status_t private_f_polls_adjust(const f_number_unsigned_t length, f_polls_t *polls) {
+ f_status_t private_f_polls_adjust(const f_number_unsigned_t length, f_polls_t * const polls) {
const f_status_t status = f_memory_adjust(polls->size, length, sizeof(f_poll_t), (void **) & polls->array);
if (F_status_is_error(status)) return status;
#endif // !defined(_di_f_polls_adjust_) || !defined(_di_f_polls_decimate_by_)
#if !defined(_di_f_polls_append_) || !defined(_di_f_pollss_append_)
- extern f_status_t private_f_polls_append(const f_poll_t source, f_polls_t *destination) {
+ extern f_status_t private_f_polls_append(const f_poll_t source, f_polls_t * const destination) {
if (destination->used + 1 > destination->size) {
const f_status_t status = private_f_polls_resize(destination->used + F_memory_default_allocation_small_d, destination);
#endif // !defined(_di_f_polls_append_) || !defined(_di_f_pollss_append_)
#if !defined(_di_f_polls_append_) || !defined(_di_f_polls_append_all_) || !defined(_di_f_pollss_append_all_)
- extern f_status_t private_f_polls_append_all(const f_polls_t source, f_polls_t *destination) {
+ extern f_status_t private_f_polls_append_all(const f_polls_t source, f_polls_t * const destination) {
if (destination->used + source.used > destination->size) {
const f_status_t status = private_f_polls_resize(destination->used + source.used, destination);
#endif // !defined(_di_f_polls_append_) || !defined(_di_f_polls_append_all_) || !defined(_di_f_pollss_append_all_)
#if !defined(_di_f_polls_resize_) || !defined(_di_f_polls_append_) || !defined(_di_f_polls_decrease_by_) || !defined(_di_f_pollss_append_)
- f_status_t private_f_polls_resize(const f_number_unsigned_t length, f_polls_t *polls) {
+ f_status_t private_f_polls_resize(const f_number_unsigned_t length, f_polls_t * const polls) {
const f_status_t status = f_memory_resize(polls->size, length, sizeof(f_poll_t), (void **) & polls->array);
if (F_status_is_error(status)) return status;
#endif // !defined(_di_f_polls_resize_) || !defined(_di_f_polls_append_) || !defined(_di_f_polls_decrease_by_) || !defined(_di_f_pollss_append_)
#if !defined(_di_f_pollss_adjust_) || !defined(_di_f_pollss_decimate_by_)
- f_status_t private_f_pollss_adjust(const f_number_unsigned_t length, f_pollss_t *pollss) {
+ f_status_t private_f_pollss_adjust(const f_number_unsigned_t length, f_pollss_t * const pollss) {
f_status_t status = F_none;
#endif // !defined(_di_f_pollss_adjust_) || !defined(_di_f_pollss_decimate_by_)
#if !defined(_di_f_pollss_decrease_by_) || !defined(_di_f_pollss_increase_) || !defined(_di_f_pollss_increase_by_) || !defined(_di_f_pollss_resize_)
- f_status_t private_f_pollss_resize(const f_number_unsigned_t length, f_pollss_t *pollss) {
+ f_status_t private_f_pollss_resize(const f_number_unsigned_t length, f_pollss_t * const pollss) {
f_status_t status = F_none;
* @see f_polls_decimate_by()
*/
#if !defined(_di_f_polls_adjust_) || !defined(_di_f_polls_decimate_by_)
- extern f_status_t private_f_polls_adjust(const f_number_unsigned_t length, f_polls_t *polls) F_attribute_visibility_internal_d;
+ extern f_status_t private_f_polls_adjust(const f_number_unsigned_t length, f_polls_t * const polls) F_attribute_visibility_internal_d;
#endif // !defined(_di_f_polls_adjust_) || !defined(_di_f_polls_decimate_by_)
/**
* @see f_pollss_append()
*/
#if !defined(_di_f_polls_append_) || !defined(_di_f_pollss_append_)
- extern f_status_t private_f_polls_append(const f_poll_t source, f_polls_t *destination) F_attribute_visibility_internal_d;
+ extern f_status_t private_f_polls_append(const f_poll_t source, f_polls_t * const destination) F_attribute_visibility_internal_d;
#endif // !defined(_di_f_polls_append_) || !defined(_di_f_pollss_append_)
/**
* @see f_pollss_append_all()
*/
#if !defined(_di_f_polls_append_) || !defined(_di_f_polls_append_all_) || !defined(_di_f_pollss_append_all_)
- extern f_status_t private_f_polls_append_all(const f_polls_t source, f_polls_t *destination) F_attribute_visibility_internal_d;
+ extern f_status_t private_f_polls_append_all(const f_polls_t source, f_polls_t * const destination) F_attribute_visibility_internal_d;
#endif // !defined(_di_f_polls_append_) || !defined(_di_f_polls_append_all_) || !defined(_di_f_pollss_append_all_)
/**
* @see f_pollss_append()
*/
#if !defined(_di_f_polls_resize_) || !defined(_di_f_polls_append_) || !defined(_di_f_polls_decrease_by_) || !defined(_di_f_pollss_append_)
- extern f_status_t private_f_polls_resize(const f_number_unsigned_t length, f_polls_t *polls) F_attribute_visibility_internal_d;
+ extern f_status_t private_f_polls_resize(const f_number_unsigned_t length, f_polls_t * const polls) F_attribute_visibility_internal_d;
#endif // !defined(_di_f_polls_resize_) || !defined(_di_f_polls_append_) || !defined(_di_f_polls_decrease_by_) || !defined(_di_f_pollss_append_)
/**
* @see f_pollss_decimate_by()
*/
#if !defined(_di_f_pollss_adjust_) || !defined(_di_f_pollss_decimate_by_)
- extern f_status_t private_f_pollss_adjust(const f_number_unsigned_t length, f_pollss_t *pollss) F_attribute_visibility_internal_d;
+ extern f_status_t private_f_pollss_adjust(const f_number_unsigned_t length, f_pollss_t * const pollss) F_attribute_visibility_internal_d;
#endif // !defined(_di_f_pollss_adjust_) || !defined(_di_f_pollss_decimate_by_)
/**
* @see f_pollss_resize()
*/
#if !defined(_di_f_pollss_decrease_by_) || !defined(_di_f_pollss_increase_) || !defined(_di_f_pollss_increase_by_) || !defined(_di_f_pollss_resize_)
- extern f_status_t private_f_pollss_resize(const f_number_unsigned_t length, f_pollss_t *pollss) F_attribute_visibility_internal_d;
+ extern f_status_t private_f_pollss_resize(const f_number_unsigned_t length, f_pollss_t * const pollss) F_attribute_visibility_internal_d;
#endif // !defined(_di_f_pollss_decrease_by_) || !defined(_di_f_pollss_increase_) || !defined(_di_f_pollss_increase_by_) || !defined(_di_f_pollss_resize_)
#ifdef __cplusplus
#endif
#if !defined(_di_f_states_adjust_) || !defined(_di_f_states_decimate_by_)
- f_status_t private_f_states_adjust(const f_number_unsigned_t length, f_states_t *states) {
+ f_status_t private_f_states_adjust(const f_number_unsigned_t length, f_states_t * const states) {
const f_status_t status = f_memory_adjust(states->size, length, sizeof(f_state_t), (void **) & states->array);
if (F_status_is_error(status)) return status;
#endif // !defined(_di_f_states_adjust_) || !defined(_di_f_states_decimate_by_)
#if !defined(_di_f_states_append_) || !defined(_di_f_statess_append_)
- extern f_status_t private_f_states_append(const f_state_t source, f_states_t *destination) {
+ extern f_status_t private_f_states_append(const f_state_t source, f_states_t * const destination) {
if (destination->used + 1 > destination->size) {
const f_status_t status = private_f_states_resize(destination->used + F_memory_default_allocation_small_d, destination);
#endif // !defined(_di_f_states_append_) || !defined(_di_f_statess_append_)
#if !defined(_di_f_states_append_) || !defined(_di_f_states_append_all_) || !defined(_di_f_statess_append_all_)
- extern f_status_t private_f_states_append_all(const f_states_t source, f_states_t *destination) {
+ extern f_status_t private_f_states_append_all(const f_states_t source, f_states_t * const destination) {
if (destination->used + source.used > destination->size) {
const f_status_t status = private_f_states_resize(destination->used + source.used, destination);
#endif // !defined(_di_f_states_append_) || !defined(_di_f_states_append_all_) || !defined(_di_f_statess_append_all_)
#if !defined(_di_f_states_resize_) || !defined(_di_f_states_append_) || !defined(_di_f_states_decrease_by_) || !defined(_di_f_statess_append_)
- f_status_t private_f_states_resize(const f_number_unsigned_t length, f_states_t *states) {
+ f_status_t private_f_states_resize(const f_number_unsigned_t length, f_states_t * const states) {
const f_status_t status = f_memory_resize(states->size, length, sizeof(f_state_t), (void **) & states->array);
if (F_status_is_error(status)) return status;
#endif // !defined(_di_f_states_resize_) || !defined(_di_f_states_append_) || !defined(_di_f_states_decrease_by_) || !defined(_di_f_statess_append_)
#if !defined(_di_f_statess_adjust_) || !defined(_di_f_statess_decimate_by_)
- f_status_t private_f_statess_adjust(const f_number_unsigned_t length, f_statess_t *statess) {
+ f_status_t private_f_statess_adjust(const f_number_unsigned_t length, f_statess_t * const statess) {
f_status_t status = F_none;
#endif // !defined(_di_f_statess_adjust_) || !defined(_di_f_statess_decimate_by_)
#if !defined(_di_f_statess_decrease_by_) || !defined(_di_f_statess_increase_) || !defined(_di_f_statess_increase_by_) || !defined(_di_f_statess_resize_)
- f_status_t private_f_statess_resize(const f_number_unsigned_t length, f_statess_t *statess) {
+ f_status_t private_f_statess_resize(const f_number_unsigned_t length, f_statess_t * const statess) {
f_status_t status = F_none;
* @see f_states_decimate_by()
*/
#if !defined(_di_f_states_adjust_) || !defined(_di_f_states_decimate_by_)
- extern f_status_t private_f_states_adjust(const f_number_unsigned_t length, f_states_t *states) F_attribute_visibility_internal_d;
+ extern f_status_t private_f_states_adjust(const f_number_unsigned_t length, f_states_t * const states) F_attribute_visibility_internal_d;
#endif // !defined(_di_f_states_adjust_) || !defined(_di_f_states_decimate_by_)
/**
* @see f_statess_append()
*/
#if !defined(_di_f_states_append_) || !defined(_di_f_statess_append_)
- extern f_status_t private_f_states_append(const f_state_t source, f_states_t *destination) F_attribute_visibility_internal_d;
+ extern f_status_t private_f_states_append(const f_state_t source, f_states_t * const destination) F_attribute_visibility_internal_d;
#endif // !defined(_di_f_states_append_) || !defined(_di_f_statess_append_)
/**
* @see f_statess_append_all()
*/
#if !defined(_di_f_states_append_) || !defined(_di_f_states_append_all_) || !defined(_di_f_statess_append_all_)
- extern f_status_t private_f_states_append_all(const f_states_t source, f_states_t *destination) F_attribute_visibility_internal_d;
+ extern f_status_t private_f_states_append_all(const f_states_t source, f_states_t * const destination) F_attribute_visibility_internal_d;
#endif // !defined(_di_f_states_append_) || !defined(_di_f_states_append_all_) || !defined(_di_f_statess_append_all_)
/**
* @see f_statess_append()
*/
#if !defined(_di_f_states_resize_) || !defined(_di_f_states_append_) || !defined(_di_f_states_decrease_by_) || !defined(_di_f_statess_append_)
- extern f_status_t private_f_states_resize(const f_number_unsigned_t length, f_states_t *states) F_attribute_visibility_internal_d;
+ extern f_status_t private_f_states_resize(const f_number_unsigned_t length, f_states_t * const states) F_attribute_visibility_internal_d;
#endif // !defined(_di_f_states_resize_) || !defined(_di_f_states_append_) || !defined(_di_f_states_decrease_by_) || !defined(_di_f_statess_append_)
/**
* @see f_statess_decimate_by()
*/
#if !defined(_di_f_statess_adjust_) || !defined(_di_f_statess_decimate_by_)
- extern f_status_t private_f_statess_adjust(const f_number_unsigned_t length, f_statess_t *statess) F_attribute_visibility_internal_d;
+ extern f_status_t private_f_statess_adjust(const f_number_unsigned_t length, f_statess_t * const statess) F_attribute_visibility_internal_d;
#endif // !defined(_di_f_statess_adjust_) || !defined(_di_f_statess_decimate_by_)
/**
* @see f_statess_resize()
*/
#if !defined(_di_f_statess_decrease_by_) || !defined(_di_f_statess_increase_) || !defined(_di_f_statess_increase_by_) || !defined(_di_f_statess_resize_)
- extern f_status_t private_f_statess_resize(const f_number_unsigned_t length, f_statess_t *statess) F_attribute_visibility_internal_d;
+ extern f_status_t private_f_statess_resize(const f_number_unsigned_t length, f_statess_t * const statess) F_attribute_visibility_internal_d;
#endif // !defined(_di_f_statess_decrease_by_) || !defined(_di_f_statess_increase_) || !defined(_di_f_statess_increase_by_) || !defined(_di_f_statess_resize_)
#ifdef __cplusplus
#endif
#if !defined(_di_f_statuss_adjust_) || !defined(_di_f_statuss_decimate_by_)
- f_status_t private_f_statuss_adjust(const f_number_unsigned_t length, f_statuss_t *statuss) {
+ f_status_t private_f_statuss_adjust(const f_number_unsigned_t length, f_statuss_t * const statuss) {
const f_status_t status = f_memory_adjust(statuss->size, length, sizeof(f_status_t), (void **) & statuss->array);
if (F_status_is_error(status)) return status;
#endif // !defined(_di_f_statuss_adjust_) || !defined(_di_f_statuss_decimate_by_)
#if !defined(_di_f_statuss_append_) || !defined(_di_f_statusss_append_)
- extern f_status_t private_f_statuss_append(const f_status_t source, f_statuss_t *destination) {
+ extern f_status_t private_f_statuss_append(const f_status_t source, f_statuss_t * const destination) {
if (destination->used + 1 > destination->size) {
const f_status_t status = private_f_statuss_resize(destination->used + F_memory_default_allocation_small_d, destination);
#endif // !defined(_di_f_statuss_append_) || !defined(_di_f_statusss_append_)
#if !defined(_di_f_statuss_append_) || !defined(_di_f_statuss_append_all_) || !defined(_di_f_statusss_append_all_)
- extern f_status_t private_f_statuss_append_all(const f_statuss_t source, f_statuss_t *destination) {
+ extern f_status_t private_f_statuss_append_all(const f_statuss_t source, f_statuss_t * const destination) {
if (destination->used + source.used > destination->size) {
const f_status_t status = private_f_statuss_resize(destination->used + source.used, destination);
#endif // !defined(_di_f_statuss_append_) || !defined(_di_f_statuss_append_all_) || !defined(_di_f_statusss_append_all_)
#if !defined(_di_f_statuss_resize_) || !defined(_di_f_statuss_append_) || !defined(_di_f_statuss_decrease_by_) || !defined(_di_f_statusss_append_)
- f_status_t private_f_statuss_resize(const f_number_unsigned_t length, f_statuss_t *statuss) {
+ f_status_t private_f_statuss_resize(const f_number_unsigned_t length, f_statuss_t * const statuss) {
const f_status_t status = f_memory_resize(statuss->size, length, sizeof(f_status_t), (void **) & statuss->array);
if (F_status_is_error(status)) return status;
#endif // !defined(_di_f_statuss_resize_) || !defined(_di_f_statuss_append_) || !defined(_di_f_statuss_decrease_by_) || !defined(_di_f_statusss_append_)
#if !defined(_di_f_statusss_adjust_) || !defined(_di_f_statusss_decimate_by_)
- f_status_t private_f_statusss_adjust(const f_number_unsigned_t length, f_statusss_t *statusss) {
+ f_status_t private_f_statusss_adjust(const f_number_unsigned_t length, f_statusss_t * const statusss) {
f_status_t status = F_none;
#endif // !defined(_di_f_statusss_adjust_) || !defined(_di_f_statusss_decimate_by_)
#if !defined(_di_f_statusss_decrease_by_) || !defined(_di_f_statusss_increase_) || !defined(_di_f_statusss_increase_by_) || !defined(_di_f_statusss_resize_)
- f_status_t private_f_statusss_resize(const f_number_unsigned_t length, f_statusss_t *statusss) {
+ f_status_t private_f_statusss_resize(const f_number_unsigned_t length, f_statusss_t * const statusss) {
f_status_t status = F_none;
* @see f_statuss_decimate_by()
*/
#if !defined(_di_f_statuss_adjust_) || !defined(_di_f_statuss_decimate_by_)
- extern f_status_t private_f_statuss_adjust(const f_number_unsigned_t length, f_statuss_t *statuss) F_attribute_visibility_internal_d;
+ extern f_status_t private_f_statuss_adjust(const f_number_unsigned_t length, f_statuss_t * const statuss) F_attribute_visibility_internal_d;
#endif // !defined(_di_f_statuss_adjust_) || !defined(_di_f_statuss_decimate_by_)
/**
* @see f_statusss_append()
*/
#if !defined(_di_f_statuss_append_) || !defined(_di_f_statusss_append_)
- extern f_status_t private_f_statuss_append(const f_status_t source, f_statuss_t *destination) F_attribute_visibility_internal_d;
+ extern f_status_t private_f_statuss_append(const f_status_t source, f_statuss_t * const destination) F_attribute_visibility_internal_d;
#endif // !defined(_di_f_statuss_append_) || !defined(_di_f_statusss_append_)
/**
* @see f_statusss_append_all()
*/
#if !defined(_di_f_statuss_append_) || !defined(_di_f_statuss_append_all_) || !defined(_di_f_statusss_append_all_)
- extern f_status_t private_f_statuss_append_all(const f_statuss_t source, f_statuss_t *destination) F_attribute_visibility_internal_d;
+ extern f_status_t private_f_statuss_append_all(const f_statuss_t source, f_statuss_t * const destination) F_attribute_visibility_internal_d;
#endif // !defined(_di_f_statuss_append_) || !defined(_di_f_statuss_append_all_) || !defined(_di_f_statusss_append_all_)
/**
* @see f_statusss_append()
*/
#if !defined(_di_f_statuss_resize_) || !defined(_di_f_statuss_append_) || !defined(_di_f_statuss_decrease_by_) || !defined(_di_f_statusss_append_)
- extern f_status_t private_f_statuss_resize(const f_number_unsigned_t length, f_statuss_t *statuss) F_attribute_visibility_internal_d;
+ extern f_status_t private_f_statuss_resize(const f_number_unsigned_t length, f_statuss_t * const statuss) F_attribute_visibility_internal_d;
#endif // !defined(_di_f_statuss_resize_) || !defined(_di_f_statuss_append_) || !defined(_di_f_statuss_decrease_by_) || !defined(_di_f_statusss_append_)
/**
* @see f_statusss_decimate_by()
*/
#if !defined(_di_f_statusss_adjust_) || !defined(_di_f_statusss_decimate_by_)
- extern f_status_t private_f_statusss_adjust(const f_number_unsigned_t length, f_statusss_t *statusss) F_attribute_visibility_internal_d;
+ extern f_status_t private_f_statusss_adjust(const f_number_unsigned_t length, f_statusss_t * const statusss) F_attribute_visibility_internal_d;
#endif // !defined(_di_f_statusss_adjust_) || !defined(_di_f_statusss_decimate_by_)
/**
* @see f_statusss_resize()
*/
#if !defined(_di_f_statusss_decrease_by_) || !defined(_di_f_statusss_increase_) || !defined(_di_f_statusss_increase_by_) || !defined(_di_f_statusss_resize_)
- extern f_status_t private_f_statusss_resize(const f_number_unsigned_t length, f_statusss_t *statusss) F_attribute_visibility_internal_d;
+ extern f_status_t private_f_statusss_resize(const f_number_unsigned_t length, f_statusss_t * const statusss) F_attribute_visibility_internal_d;
#endif // !defined(_di_f_statusss_decrease_by_) || !defined(_di_f_statusss_increase_) || !defined(_di_f_statusss_increase_by_) || !defined(_di_f_statusss_resize_)
#ifdef __cplusplus
#endif
#if !defined(_di_f_uint128s_adjust_) || !defined(_di_f_uint128s_decimate_by_)
- f_status_t private_f_uint128s_adjust(const f_number_unsigned_t length, f_uint128s_t *uint128s) {
+ f_status_t private_f_uint128s_adjust(const f_number_unsigned_t length, f_uint128s_t * const uint128s) {
const f_status_t status = f_memory_adjust(uint128s->size, length, sizeof(f_uint128s_t), (void **) & uint128s->array);
if (F_status_is_error(status)) return status;
#endif // !defined(_di_f_uint128s_adjust_) || !defined(_di_f_uint128s_decimate_by_)
#if !defined(_di_f_uint128s_append_) || !defined(_di_f_uint128ss_append_)
- extern f_status_t private_f_uint128s_append(const uint128_t source, f_uint128s_t *destination) {
+ extern f_status_t private_f_uint128s_append(const uint128_t source, f_uint128s_t * const destination) {
if (destination->used + 1 > destination->size) {
const f_status_t status = private_f_uint128s_resize(destination->used + F_memory_default_allocation_small_d, destination);
#endif // !defined(_di_f_uint128s_append_) || !defined(_di_f_uint128ss_append_)
#if !defined(_di_f_uint128s_append_) || !defined(_di_f_uint128s_append_all_) || !defined(_di_f_uint128ss_append_all_)
- extern f_status_t private_f_uint128s_append_all(const f_uint128s_t source, f_uint128s_t *destination) {
+ extern f_status_t private_f_uint128s_append_all(const f_uint128s_t source, f_uint128s_t * const destination) {
if (destination->used + source.used > destination->size) {
const f_status_t status = private_f_uint128s_resize(destination->used + source.used, destination);
#endif // !defined(_di_f_uint128s_append_) || !defined(_di_f_uint128s_append_all_) || !defined(_di_f_uint128ss_append_all_)
#if !defined(_di_f_uint128s_resize_) || !defined(_di_f_uint128s_append_) || !defined(_di_f_uint128s_decrease_by_) || !defined(_di_f_uint128ss_append_)
- f_status_t private_f_uint128s_resize(const f_number_unsigned_t length, f_uint128s_t *uint128s) {
+ f_status_t private_f_uint128s_resize(const f_number_unsigned_t length, f_uint128s_t * const uint128s) {
const f_status_t status = f_memory_resize(uint128s->size, length, sizeof(f_uint128s_t), (void **) & uint128s->array);
if (F_status_is_error(status)) return status;
#endif // !defined(_di_f_uint128s_resize_) || !defined(_di_f_uint128s_append_) || !defined(_di_f_uint128s_decrease_by_) || !defined(_di_f_uint128ss_append_)
#if !defined(_di_f_uint128ss_adjust_) || !defined(_di_f_uint128ss_decimate_by_)
- f_status_t private_f_uint128ss_adjust(const f_number_unsigned_t length, f_uint128ss_t *uint128ss) {
+ f_status_t private_f_uint128ss_adjust(const f_number_unsigned_t length, f_uint128ss_t * const uint128ss) {
f_status_t status = F_none;
#endif // !defined(_di_f_uint128ss_adjust_) || !defined(_di_f_uint128ss_decimate_by_)
#if !defined(_di_f_uint128ss_decrease_by_) || !defined(_di_f_uint128ss_increase_) || !defined(_di_f_uint128ss_increase_by_) || !defined(_di_f_uint128ss_resize_)
- f_status_t private_f_uint128ss_resize(const f_number_unsigned_t length, f_uint128ss_t *uint128ss) {
+ f_status_t private_f_uint128ss_resize(const f_number_unsigned_t length, f_uint128ss_t * const uint128ss) {
f_status_t status = F_none;
* @see f_uint128s_decimate_by()
*/
#if !defined(_di_f_uint128s_adjust_) || !defined(_di_f_uint128s_decimate_by_)
- extern f_status_t private_f_uint128s_adjust(const f_number_unsigned_t length, f_uint128s_t *uint128s) F_attribute_visibility_internal_d;
+ extern f_status_t private_f_uint128s_adjust(const f_number_unsigned_t length, f_uint128s_t * const uint128s) F_attribute_visibility_internal_d;
#endif // !defined(_di_f_uint128s_adjust_) || !defined(_di_f_uint128s_decimate_by_)
/**
* @see f_uint128ss_append()
*/
#if !defined(_di_f_uint128s_append_) || !defined(_di_f_uint128ss_append_)
- extern f_status_t private_f_uint128s_append(const uint128_t source, f_uint128s_t *destination) F_attribute_visibility_internal_d;
+ extern f_status_t private_f_uint128s_append(const uint128_t source, f_uint128s_t * const destination) F_attribute_visibility_internal_d;
#endif // !defined(_di_f_uint128s_append_) || !defined(_di_f_uint128ss_append_)
/**
* @see f_uint128ss_append_all()
*/
#if !defined(_di_f_uint128s_append_) || !defined(_di_f_uint128s_append_all_) || !defined(_di_f_uint128ss_append_all_)
- extern f_status_t private_f_uint128s_append_all(const f_uint128s_t source, f_uint128s_t *destination) F_attribute_visibility_internal_d;
+ extern f_status_t private_f_uint128s_append_all(const f_uint128s_t source, f_uint128s_t * const destination) F_attribute_visibility_internal_d;
#endif // !defined(_di_f_uint128s_append_) || !defined(_di_f_uint128s_append_all_) || !defined(_di_f_uint128ss_append_all_)
/**
* @see f_uint128ss_append()
*/
#if !defined(_di_f_uint128s_resize_) || !defined(_di_f_uint128s_append_) || !defined(_di_f_uint128s_decrease_by_) || !defined(_di_f_uint128ss_append_)
- extern f_status_t private_f_uint128s_resize(const f_number_unsigned_t length, f_uint128s_t *uint128s) F_attribute_visibility_internal_d;
+ extern f_status_t private_f_uint128s_resize(const f_number_unsigned_t length, f_uint128s_t * const uint128s) F_attribute_visibility_internal_d;
#endif // !defined(_di_f_uint128s_resize_) || !defined(_di_f_uint128s_append_) || !defined(_di_f_uint128s_decrease_by_) || !defined(_di_f_uint128ss_append_)
/**
* @see f_uint128ss_decimate_by()
*/
#if !defined(_di_f_uint128ss_adjust_) || !defined(_di_f_uint128ss_decimate_by_)
- extern f_status_t private_f_uint128ss_adjust(const f_number_unsigned_t length, f_uint128ss_t *uint128ss) F_attribute_visibility_internal_d;
+ extern f_status_t private_f_uint128ss_adjust(const f_number_unsigned_t length, f_uint128ss_t * const uint128ss) F_attribute_visibility_internal_d;
#endif // !defined(_di_f_uint128ss_adjust_) || !defined(_di_f_uint128ss_decimate_by_)
/**
* @see f_uint128ss_resize()
*/
#if !defined(_di_f_uint128ss_decrease_by_) || !defined(_di_f_uint128ss_increase_) || !defined(_di_f_uint128ss_increase_by_) || !defined(_di_f_uint128ss_resize_)
- extern f_status_t private_f_uint128ss_resize(const f_number_unsigned_t length, f_uint128ss_t *uint128ss) F_attribute_visibility_internal_d;
+ extern f_status_t private_f_uint128ss_resize(const f_number_unsigned_t length, f_uint128ss_t * const uint128ss) F_attribute_visibility_internal_d;
#endif // !defined(_di_f_uint128ss_decrease_by_) || !defined(_di_f_uint128ss_increase_) || !defined(_di_f_uint128ss_increase_by_) || !defined(_di_f_uint128ss_resize_)
#ifdef __cplusplus
#endif
#if !defined(_di_f_uint16s_adjust_) || !defined(_di_f_uint16s_decimate_by_)
- f_status_t private_f_uint16s_adjust(const f_number_unsigned_t length, f_uint16s_t *uint16s) {
+ f_status_t private_f_uint16s_adjust(const f_number_unsigned_t length, f_uint16s_t * const uint16s) {
const f_status_t status = f_memory_adjust(uint16s->size, length, sizeof(uint16_t), (void **) & uint16s->array);
if (F_status_is_error(status)) return status;
#endif // !defined(_di_f_uint16s_adjust_) || !defined(_di_f_uint16s_decimate_by_)
#if !defined(_di_f_uint16s_append_) || !defined(_di_f_uint16ss_append_)
- extern f_status_t private_f_uint16s_append(const uint16_t source, f_uint16s_t *destination) {
+ extern f_status_t private_f_uint16s_append(const uint16_t source, f_uint16s_t * const destination) {
if (destination->used + 1 > destination->size) {
const f_status_t status = private_f_uint16s_resize(destination->used + F_memory_default_allocation_small_d, destination);
#endif // !defined(_di_f_uint16s_append_) || !defined(_di_f_uint16ss_append_)
#if !defined(_di_f_uint16s_append_) || !defined(_di_f_uint16s_append_all_) || !defined(_di_f_uint16ss_append_all_)
- extern f_status_t private_f_uint16s_append_all(const f_uint16s_t source, f_uint16s_t *destination) {
+ extern f_status_t private_f_uint16s_append_all(const f_uint16s_t source, f_uint16s_t * const destination) {
if (destination->used + source.used > destination->size) {
const f_status_t status = private_f_uint16s_resize(destination->used + source.used, destination);
#endif // !defined(_di_f_uint16s_append_) || !defined(_di_f_uint16s_append_all_) || !defined(_di_f_uint16ss_append_all_)
#if !defined(_di_f_uint16s_resize_) || !defined(_di_f_uint16s_append_) || !defined(_di_f_uint16s_decrease_by_) || !defined(_di_f_uint16ss_append_)
- f_status_t private_f_uint16s_resize(const f_number_unsigned_t length, f_uint16s_t *uint16s) {
+ f_status_t private_f_uint16s_resize(const f_number_unsigned_t length, f_uint16s_t * const uint16s) {
const f_status_t status = f_memory_resize(uint16s->size, length, sizeof(uint16_t), (void **) & uint16s->array);
if (F_status_is_error(status)) return status;
#endif // !defined(_di_f_uint16s_resize_) || !defined(_di_f_uint16s_append_) || !defined(_di_f_uint16s_decrease_by_) || !defined(_di_f_uint16ss_append_)
#if !defined(_di_f_uint16ss_adjust_) || !defined(_di_f_uint16ss_decimate_by_)
- f_status_t private_f_uint16ss_adjust(const f_number_unsigned_t length, f_uint16ss_t *uint16ss) {
+ f_status_t private_f_uint16ss_adjust(const f_number_unsigned_t length, f_uint16ss_t * const uint16ss) {
f_status_t status = F_none;
#endif // !defined(_di_f_uint16ss_adjust_) || !defined(_di_f_uint16ss_decimate_by_)
#if !defined(_di_f_uint16ss_decrease_by_) || !defined(_di_f_uint16ss_increase_) || !defined(_di_f_uint16ss_increase_by_) || !defined(_di_f_uint16ss_resize_)
- f_status_t private_f_uint16ss_resize(const f_number_unsigned_t length, f_uint16ss_t *uint16ss) {
+ f_status_t private_f_uint16ss_resize(const f_number_unsigned_t length, f_uint16ss_t * const uint16ss) {
f_status_t status = F_none;
* @see f_uint16s_decimate_by()
*/
#if !defined(_di_f_uint16s_adjust_) || !defined(_di_f_uint16s_decimate_by_)
- extern f_status_t private_f_uint16s_adjust(const f_number_unsigned_t length, f_uint16s_t *uint16s) F_attribute_visibility_internal_d;
+ extern f_status_t private_f_uint16s_adjust(const f_number_unsigned_t length, f_uint16s_t * const uint16s) F_attribute_visibility_internal_d;
#endif // !defined(_di_f_uint16s_adjust_) || !defined(_di_f_uint16s_decimate_by_)
/**
* @see f_uint16ss_append()
*/
#if !defined(_di_f_uint16s_append_) || !defined(_di_f_uint16ss_append_)
- extern f_status_t private_f_uint16s_append(const uint16_t source, f_uint16s_t *destination) F_attribute_visibility_internal_d;
+ extern f_status_t private_f_uint16s_append(const uint16_t source, f_uint16s_t * const destination) F_attribute_visibility_internal_d;
#endif // !defined(_di_f_uint16s_append_) || !defined(_di_f_uint16ss_append_)
/**
* @see f_uint16ss_append_all()
*/
#if !defined(_di_f_uint16s_append_) || !defined(_di_f_uint16s_append_all_) || !defined(_di_f_uint16ss_append_all_)
- extern f_status_t private_f_uint16s_append_all(const f_uint16s_t source, f_uint16s_t *destination) F_attribute_visibility_internal_d;
+ extern f_status_t private_f_uint16s_append_all(const f_uint16s_t source, f_uint16s_t * const destination) F_attribute_visibility_internal_d;
#endif // !defined(_di_f_uint16s_append_) || !defined(_di_f_uint16s_append_all_) || !defined(_di_f_uint16ss_append_all_)
/**
* @see f_uint16ss_append()
*/
#if !defined(_di_f_uint16s_resize_) || !defined(_di_f_uint16s_append_) || !defined(_di_f_uint16s_decrease_by_) || !defined(_di_f_uint16ss_append_)
- extern f_status_t private_f_uint16s_resize(const f_number_unsigned_t length, f_uint16s_t *uint16s) F_attribute_visibility_internal_d;
+ extern f_status_t private_f_uint16s_resize(const f_number_unsigned_t length, f_uint16s_t * const uint16s) F_attribute_visibility_internal_d;
#endif // !defined(_di_f_uint16s_resize_) || !defined(_di_f_uint16s_append_) || !defined(_di_f_uint16s_decrease_by_) || !defined(_di_f_uint16ss_append_)
/**
* @see f_uint16ss_decimate_by()
*/
#if !defined(_di_f_uint16ss_adjust_) || !defined(_di_f_uint16ss_decimate_by_)
- extern f_status_t private_f_uint16ss_adjust(const f_number_unsigned_t length, f_uint16ss_t *uint16ss) F_attribute_visibility_internal_d;
+ extern f_status_t private_f_uint16ss_adjust(const f_number_unsigned_t length, f_uint16ss_t * const uint16ss) F_attribute_visibility_internal_d;
#endif // !defined(_di_f_uint16ss_adjust_) || !defined(_di_f_uint16ss_decimate_by_)
/**
* @see f_uint16ss_resize()
*/
#if !defined(_di_f_uint16ss_decrease_by_) || !defined(_di_f_uint16ss_increase_) || !defined(_di_f_uint16ss_increase_by_) || !defined(_di_f_uint16ss_resize_)
- extern f_status_t private_f_uint16ss_resize(const f_number_unsigned_t length, f_uint16ss_t *uint16ss) F_attribute_visibility_internal_d;
+ extern f_status_t private_f_uint16ss_resize(const f_number_unsigned_t length, f_uint16ss_t * const uint16ss) F_attribute_visibility_internal_d;
#endif // !defined(_di_f_uint16ss_decrease_by_) || !defined(_di_f_uint16ss_increase_) || !defined(_di_f_uint16ss_increase_by_) || !defined(_di_f_uint16ss_resize_)
#ifdef __cplusplus
#endif
#if !defined(_di_f_uint32s_adjust_) || !defined(_di_f_uint32s_decimate_by_)
- f_status_t private_f_uint32s_adjust(const f_number_unsigned_t length, f_uint32s_t *uint32s) {
+ f_status_t private_f_uint32s_adjust(const f_number_unsigned_t length, f_uint32s_t * const uint32s) {
const f_status_t status = f_memory_adjust(uint32s->size, length, sizeof(uint32_t), (void **) & uint32s->array);
if (F_status_is_error(status)) return status;
#endif // !defined(_di_f_uint32s_adjust_) || !defined(_di_f_uint32s_decimate_by_)
#if !defined(_di_f_uint32s_append_) || !defined(_di_f_uint32ss_append_)
- extern f_status_t private_f_uint32s_append(const uint32_t source, f_uint32s_t *destination) {
+ extern f_status_t private_f_uint32s_append(const uint32_t source, f_uint32s_t * const destination) {
if (destination->used + 1 > destination->size) {
const f_status_t status = private_f_uint32s_resize(destination->used + F_memory_default_allocation_small_d, destination);
#endif // !defined(_di_f_uint32s_append_) || !defined(_di_f_uint32ss_append_)
#if !defined(_di_f_uint32s_append_) || !defined(_di_f_uint32s_append_all_) || !defined(_di_f_uint32ss_append_all_)
- extern f_status_t private_f_uint32s_append_all(const f_uint32s_t source, f_uint32s_t *destination) {
+ extern f_status_t private_f_uint32s_append_all(const f_uint32s_t source, f_uint32s_t * const destination) {
if (destination->used + source.used > destination->size) {
const f_status_t status = private_f_uint32s_resize(destination->used + source.used, destination);
#endif // !defined(_di_f_uint32s_append_) || !defined(_di_f_uint32s_append_all_) || !defined(_di_f_uint32ss_append_all_)
#if !defined(_di_f_uint32s_resize_) || !defined(_di_f_uint32s_append_) || !defined(_di_f_uint32s_decrease_by_) || !defined(_di_f_uint32ss_append_)
- f_status_t private_f_uint32s_resize(const f_number_unsigned_t length, f_uint32s_t *uint32s) {
+ f_status_t private_f_uint32s_resize(const f_number_unsigned_t length, f_uint32s_t * const uint32s) {
const f_status_t status = f_memory_resize(uint32s->size, length, sizeof(uint32_t), (void **) & uint32s->array);
if (F_status_is_error(status)) return status;
#endif // !defined(_di_f_uint32s_resize_) || !defined(_di_f_uint32s_append_) || !defined(_di_f_uint32s_decrease_by_) || !defined(_di_f_uint32ss_append_)
#if !defined(_di_f_uint32ss_adjust_) || !defined(_di_f_uint32ss_decimate_by_)
- f_status_t private_f_uint32ss_adjust(const f_number_unsigned_t length, f_uint32ss_t *uint32ss) {
+ f_status_t private_f_uint32ss_adjust(const f_number_unsigned_t length, f_uint32ss_t * const uint32ss) {
f_status_t status = F_none;
#endif // !defined(_di_f_uint32ss_adjust_) || !defined(_di_f_uint32ss_decimate_by_)
#if !defined(_di_f_uint32ss_decrease_by_) || !defined(_di_f_uint32ss_increase_) || !defined(_di_f_uint32ss_increase_by_) || !defined(_di_f_uint32ss_resize_)
- f_status_t private_f_uint32ss_resize(const f_number_unsigned_t length, f_uint32ss_t *uint32ss) {
+ f_status_t private_f_uint32ss_resize(const f_number_unsigned_t length, f_uint32ss_t * const uint32ss) {
f_status_t status = F_none;
* @see f_uint32s_decimate_by()
*/
#if !defined(_di_f_uint32s_adjust_) || !defined(_di_f_uint32s_decimate_by_)
- extern f_status_t private_f_uint32s_adjust(const f_number_unsigned_t length, f_uint32s_t *uint32s) F_attribute_visibility_internal_d;
+ extern f_status_t private_f_uint32s_adjust(const f_number_unsigned_t length, f_uint32s_t * const uint32s) F_attribute_visibility_internal_d;
#endif // !defined(_di_f_uint32s_adjust_) || !defined(_di_f_uint32s_decimate_by_)
/**
* @see f_uint32ss_append()
*/
#if !defined(_di_f_uint32s_append_) || !defined(_di_f_uint32ss_append_)
- extern f_status_t private_f_uint32s_append(const uint32_t source, f_uint32s_t *destination) F_attribute_visibility_internal_d;
+ extern f_status_t private_f_uint32s_append(const uint32_t source, f_uint32s_t * const destination) F_attribute_visibility_internal_d;
#endif // !defined(_di_f_uint32s_append_) || !defined(_di_f_uint32ss_append_)
/**
* @see f_uint32ss_append_all()
*/
#if !defined(_di_f_uint32s_append_) || !defined(_di_f_uint32s_append_all_) || !defined(_di_f_uint32ss_append_all_)
- extern f_status_t private_f_uint32s_append_all(const f_uint32s_t source, f_uint32s_t *destination) F_attribute_visibility_internal_d;
+ extern f_status_t private_f_uint32s_append_all(const f_uint32s_t source, f_uint32s_t * const destination) F_attribute_visibility_internal_d;
#endif // !defined(_di_f_uint32s_append_) || !defined(_di_f_uint32s_append_all_) || !defined(_di_f_uint32ss_append_all_)
/**
* @see f_uint32ss_append()
*/
#if !defined(_di_f_uint32s_resize_) || !defined(_di_f_uint32s_append_) || !defined(_di_f_uint32s_decrease_by_) || !defined(_di_f_uint32ss_append_)
- extern f_status_t private_f_uint32s_resize(const f_number_unsigned_t length, f_uint32s_t *uint32s) F_attribute_visibility_internal_d;
+ extern f_status_t private_f_uint32s_resize(const f_number_unsigned_t length, f_uint32s_t * const uint32s) F_attribute_visibility_internal_d;
#endif // !defined(_di_f_uint32s_resize_) || !defined(_di_f_uint32s_append_) || !defined(_di_f_uint32s_decrease_by_) || !defined(_di_f_uint32ss_append_)
/**
* @see f_uint32ss_decimate_by()
*/
#if !defined(_di_f_uint32ss_adjust_) || !defined(_di_f_uint32ss_decimate_by_)
- extern f_status_t private_f_uint32ss_adjust(const f_number_unsigned_t length, f_uint32ss_t *uint32ss) F_attribute_visibility_internal_d;
+ extern f_status_t private_f_uint32ss_adjust(const f_number_unsigned_t length, f_uint32ss_t * const uint32ss) F_attribute_visibility_internal_d;
#endif // !defined(_di_f_uint32ss_adjust_) || !defined(_di_f_uint32ss_decimate_by_)
/**
* @see f_uint32ss_resize()
*/
#if !defined(_di_f_uint32ss_decrease_by_) || !defined(_di_f_uint32ss_increase_) || !defined(_di_f_uint32ss_increase_by_) || !defined(_di_f_uint32ss_resize_)
- extern f_status_t private_f_uint32ss_resize(const f_number_unsigned_t length, f_uint32ss_t *uint32ss) F_attribute_visibility_internal_d;
+ extern f_status_t private_f_uint32ss_resize(const f_number_unsigned_t length, f_uint32ss_t * const uint32ss) F_attribute_visibility_internal_d;
#endif // !defined(_di_f_uint32ss_decrease_by_) || !defined(_di_f_uint32ss_increase_) || !defined(_di_f_uint32ss_increase_by_) || !defined(_di_f_uint32ss_resize_)
#ifdef __cplusplus
#endif
#if !defined(_di_f_uint64s_adjust_) || !defined(_di_f_uint64s_decimate_by_)
- f_status_t private_f_uint64s_adjust(const f_number_unsigned_t length, f_uint64s_t *uint64s) {
+ f_status_t private_f_uint64s_adjust(const f_number_unsigned_t length, f_uint64s_t * const uint64s) {
const f_status_t status = f_memory_adjust(uint64s->size, length, sizeof(uint64_t), (void **) & uint64s->array);
if (F_status_is_error(status)) return status;
#endif // !defined(_di_f_uint64s_adjust_) || !defined(_di_f_uint64s_decimate_by_)
#if !defined(_di_f_uint64s_append_) || !defined(_di_f_uint64ss_append_)
- extern f_status_t private_f_uint64s_append(const uint64_t source, f_uint64s_t *destination) {
+ extern f_status_t private_f_uint64s_append(const uint64_t source, f_uint64s_t * const destination) {
if (destination->used + 1 > destination->size) {
const f_status_t status = private_f_uint64s_resize(destination->used + F_memory_default_allocation_small_d, destination);
#endif // !defined(_di_f_uint64s_append_) || !defined(_di_f_uint64ss_append_)
#if !defined(_di_f_uint64s_append_) || !defined(_di_f_uint64s_append_all_) || !defined(_di_f_uint64ss_append_all_)
- extern f_status_t private_f_uint64s_append_all(const f_uint64s_t source, f_uint64s_t *destination) {
+ extern f_status_t private_f_uint64s_append_all(const f_uint64s_t source, f_uint64s_t * const destination) {
if (destination->used + source.used > destination->size) {
const f_status_t status = private_f_uint64s_resize(destination->used + source.used, destination);
#endif // !defined(_di_f_uint64s_append_) || !defined(_di_f_uint64s_append_all_) || !defined(_di_f_uint64ss_append_all_)
#if !defined(_di_f_uint64s_resize_) || !defined(_di_f_uint64s_append_) || !defined(_di_f_uint64s_decrease_by_) || !defined(_di_f_uint64ss_append_)
- f_status_t private_f_uint64s_resize(const f_number_unsigned_t length, f_uint64s_t *uint64s) {
+ f_status_t private_f_uint64s_resize(const f_number_unsigned_t length, f_uint64s_t * const uint64s) {
const f_status_t status = f_memory_resize(uint64s->size, length, sizeof(uint64_t), (void **) & uint64s->array);
if (F_status_is_error(status)) return status;
#endif // !defined(_di_f_uint64s_resize_) || !defined(_di_f_uint64s_append_) || !defined(_di_f_uint64s_decrease_by_) || !defined(_di_f_uint64ss_append_)
#if !defined(_di_f_uint64ss_adjust_) || !defined(_di_f_uint64ss_decimate_by_)
- f_status_t private_f_uint64ss_adjust(const f_number_unsigned_t length, f_uint64ss_t *uint64ss) {
+ f_status_t private_f_uint64ss_adjust(const f_number_unsigned_t length, f_uint64ss_t * const uint64ss) {
f_status_t status = F_none;
#endif // !defined(_di_f_uint64ss_adjust_) || !defined(_di_f_uint64ss_decimate_by_)
#if !defined(_di_f_uint64ss_decrease_by_) || !defined(_di_f_uint64ss_increase_) || !defined(_di_f_uint64ss_increase_by_) || !defined(_di_f_uint64ss_resize_)
- f_status_t private_f_uint64ss_resize(const f_number_unsigned_t length, f_uint64ss_t *uint64ss) {
+ f_status_t private_f_uint64ss_resize(const f_number_unsigned_t length, f_uint64ss_t * const uint64ss) {
f_status_t status = F_none;
* @see f_uint64s_decimate_by()
*/
#if !defined(_di_f_uint64s_adjust_) || !defined(_di_f_uint64s_decimate_by_)
- extern f_status_t private_f_uint64s_adjust(const f_number_unsigned_t length, f_uint64s_t *uint64s) F_attribute_visibility_internal_d;
+ extern f_status_t private_f_uint64s_adjust(const f_number_unsigned_t length, f_uint64s_t * const uint64s) F_attribute_visibility_internal_d;
#endif // !defined(_di_f_uint64s_adjust_) || !defined(_di_f_uint64s_decimate_by_)
/**
* @see f_uint64ss_append()
*/
#if !defined(_di_f_uint64s_append_) || !defined(_di_f_uint64ss_append_)
- extern f_status_t private_f_uint64s_append(const uint64_t source, f_uint64s_t *destination) F_attribute_visibility_internal_d;
+ extern f_status_t private_f_uint64s_append(const uint64_t source, f_uint64s_t * const destination) F_attribute_visibility_internal_d;
#endif // !defined(_di_f_uint64s_append_) || !defined(_di_f_uint64ss_append_)
/**
* @see f_uint64ss_append_all()
*/
#if !defined(_di_f_uint64s_append_) || !defined(_di_f_uint64s_append_all_) || !defined(_di_f_uint64ss_append_all_)
- extern f_status_t private_f_uint64s_append_all(const f_uint64s_t source, f_uint64s_t *destination) F_attribute_visibility_internal_d;
+ extern f_status_t private_f_uint64s_append_all(const f_uint64s_t source, f_uint64s_t * const destination) F_attribute_visibility_internal_d;
#endif // !defined(_di_f_uint64s_append_) || !defined(_di_f_uint64s_append_all_) || !defined(_di_f_uint64ss_append_all_)
/**
* @see f_uint64ss_append()
*/
#if !defined(_di_f_uint64s_resize_) || !defined(_di_f_uint64s_append_) || !defined(_di_f_uint64s_decrease_by_) || !defined(_di_f_uint64ss_append_)
- extern f_status_t private_f_uint64s_resize(const f_number_unsigned_t length, f_uint64s_t *uint64s) F_attribute_visibility_internal_d;
+ extern f_status_t private_f_uint64s_resize(const f_number_unsigned_t length, f_uint64s_t * const uint64s) F_attribute_visibility_internal_d;
#endif // !defined(_di_f_uint64s_resize_) || !defined(_di_f_uint64s_append_) || !defined(_di_f_uint64s_decrease_by_) || !defined(_di_f_uint64ss_append_)
/**
* @see f_uint64ss_decimate_by()
*/
#if !defined(_di_f_uint64ss_adjust_) || !defined(_di_f_uint64ss_decimate_by_)
- extern f_status_t private_f_uint64ss_adjust(const f_number_unsigned_t length, f_uint64ss_t *uint64ss) F_attribute_visibility_internal_d;
+ extern f_status_t private_f_uint64ss_adjust(const f_number_unsigned_t length, f_uint64ss_t * const uint64ss) F_attribute_visibility_internal_d;
#endif // !defined(_di_f_uint64ss_adjust_) || !defined(_di_f_uint64ss_decimate_by_)
/**
* @see f_uint64ss_resize()
*/
#if !defined(_di_f_uint64ss_decrease_by_) || !defined(_di_f_uint64ss_increase_) || !defined(_di_f_uint64ss_increase_by_) || !defined(_di_f_uint64ss_resize_)
- extern f_status_t private_f_uint64ss_resize(const f_number_unsigned_t length, f_uint64ss_t *uint64ss) F_attribute_visibility_internal_d;
+ extern f_status_t private_f_uint64ss_resize(const f_number_unsigned_t length, f_uint64ss_t * const uint64ss) F_attribute_visibility_internal_d;
#endif // !defined(_di_f_uint64ss_decrease_by_) || !defined(_di_f_uint64ss_increase_) || !defined(_di_f_uint64ss_increase_by_) || !defined(_di_f_uint64ss_resize_)
#ifdef __cplusplus
#endif
#if !defined(_di_f_uint8s_adjust_) || !defined(_di_f_uint8s_decimate_by_)
- f_status_t private_f_uint8s_adjust(const f_number_unsigned_t length, f_uint8s_t *uint8s) {
+ f_status_t private_f_uint8s_adjust(const f_number_unsigned_t length, f_uint8s_t * const uint8s) {
const f_status_t status = f_memory_adjust(uint8s->size, length, sizeof(uint8_t), (void **) & uint8s->array);
if (F_status_is_error(status)) return status;
#endif // !defined(_di_f_uint8s_adjust_) || !defined(_di_f_uint8s_decimate_by_)
#if !defined(_di_f_uint8s_append_) || !defined(_di_f_uint8ss_append_)
- extern f_status_t private_f_uint8s_append(const uint8_t source, f_uint8s_t *destination) {
+ extern f_status_t private_f_uint8s_append(const uint8_t source, f_uint8s_t * const destination) {
if (destination->used + 1 > destination->size) {
const f_status_t status = private_f_uint8s_resize(destination->used + F_memory_default_allocation_small_d, destination);
#endif // !defined(_di_f_uint8s_append_) || !defined(_di_f_uint8ss_append_)
#if !defined(_di_f_uint8s_append_) || !defined(_di_f_uint8s_append_all_) || !defined(_di_f_uint8ss_append_all_)
- extern f_status_t private_f_uint8s_append_all(const f_uint8s_t source, f_uint8s_t *destination) {
+ extern f_status_t private_f_uint8s_append_all(const f_uint8s_t source, f_uint8s_t * const destination) {
if (destination->used + source.used > destination->size) {
const f_status_t status = private_f_uint8s_resize(destination->used + source.used, destination);
#endif // !defined(_di_f_uint8s_append_) || !defined(_di_f_uint8s_append_all_) || !defined(_di_f_uint8ss_append_all_)
#if !defined(_di_f_uint8s_append_) || !defined(_di_f_uint8s_append_all_) || !defined(_di_f_uint8s_decrease_by_) || !defined(_di_f_uint8s_increase_) || !defined(_di_f_uint8s_increase_by_) || !defined(_di_f_uint8s_resize_) || !defined(_di_f_uint8ss_append_) || !defined(_di_f_uint8ss_append_all_)
- f_status_t private_f_uint8s_resize(const f_number_unsigned_t length, f_uint8s_t *uint8s) {
+ f_status_t private_f_uint8s_resize(const f_number_unsigned_t length, f_uint8s_t * const uint8s) {
const f_status_t status = f_memory_resize(uint8s->size, length, sizeof(uint8_t), (void **) & uint8s->array);
if (F_status_is_error(status)) return status;
#endif // !defined(_di_f_uint8s_append_) || !defined(_di_f_uint8s_append_all_) || !defined(_di_f_uint8s_decrease_by_) || !defined(_di_f_uint8s_increase_) || !defined(_di_f_uint8s_increase_by_) || !defined(_di_f_uint8s_resize_) || !defined(_di_f_uint8ss_append_) || !defined(_di_f_uint8ss_append_all_)
#if !defined(_di_f_uint8ss_adjust_) || !defined(_di_f_uint8ss_decimate_by_)
- f_status_t private_f_uint8ss_adjust(const f_number_unsigned_t length, f_uint8ss_t *uint8ss) {
+ f_status_t private_f_uint8ss_adjust(const f_number_unsigned_t length, f_uint8ss_t * const uint8ss) {
f_status_t status = F_none;
#endif // !defined(_di_f_uint8ss_adjust_) || !defined(_di_f_uint8ss_decimate_by_)
#if !defined(_di_f_uint8ss_decrease_by_) || !defined(_di_f_uint8ss_increase_) || !defined(_di_f_uint8ss_increase_by_) || !defined(_di_f_uint8ss_resize_)
- f_status_t private_f_uint8ss_resize(const f_number_unsigned_t length, f_uint8ss_t *uint8ss) {
+ f_status_t private_f_uint8ss_resize(const f_number_unsigned_t length, f_uint8ss_t * const uint8ss) {
f_status_t status = F_none;
* @see f_uint8s_decimate_by()
*/
#if !defined(_di_f_uint8s_adjust_) || !defined(_di_f_uint8s_decimate_by_)
- extern f_status_t private_f_uint8s_adjust(const f_number_unsigned_t length, f_uint8s_t *uint8s) F_attribute_visibility_internal_d;
+ extern f_status_t private_f_uint8s_adjust(const f_number_unsigned_t length, f_uint8s_t * const uint8s) F_attribute_visibility_internal_d;
#endif // !defined(_di_f_uint8s_adjust_) || !defined(_di_f_uint8s_decimate_by_)
/**
* @see f_uint8ss_append()
*/
#if !defined(_di_f_uint8s_append_) || !defined(_di_f_uint8ss_append_)
- extern f_status_t private_f_uint8s_append(const uint8_t source, f_uint8s_t *destination) F_attribute_visibility_internal_d;
+ extern f_status_t private_f_uint8s_append(const uint8_t source, f_uint8s_t * const destination) F_attribute_visibility_internal_d;
#endif // !defined(_di_f_uint8s_append_) || !defined(_di_f_uint8ss_append_)
/**
* @see f_uint8ss_append_all()
*/
#if !defined(_di_f_uint8s_append_) || !defined(_di_f_uint8s_append_all_) || !defined(_di_f_uint8ss_append_all_)
- extern f_status_t private_f_uint8s_append_all(const f_uint8s_t source, f_uint8s_t *destination) F_attribute_visibility_internal_d;
+ extern f_status_t private_f_uint8s_append_all(const f_uint8s_t source, f_uint8s_t * const destination) F_attribute_visibility_internal_d;
#endif // !defined(_di_f_uint8s_append_) || !defined(_di_f_uint8s_append_all_) || !defined(_di_f_uint8ss_append_all_)
/**
*
*/
#if !defined(_di_f_uint8s_append_) || !defined(_di_f_uint8s_append_all_) || !defined(_di_f_uint8s_decrease_by_) || !defined(_di_f_uint8s_increase_) || !defined(_di_f_uint8s_increase_by_) || !defined(_di_f_uint8s_resize_) || !defined(_di_f_uint8ss_append_) || !defined(_di_f_uint8ss_append_all_)
- extern f_status_t private_f_uint8s_resize(const f_number_unsigned_t length, f_uint8s_t *uint8s) F_attribute_visibility_internal_d;
+ extern f_status_t private_f_uint8s_resize(const f_number_unsigned_t length, f_uint8s_t * const uint8s) F_attribute_visibility_internal_d;
#endif // !defined(_di_f_uint8s_append_) || !defined(_di_f_uint8s_append_all_) || !defined(_di_f_uint8s_decrease_by_) || !defined(_di_f_uint8s_increase_) || !defined(_di_f_uint8s_increase_by_) || !defined(_di_f_uint8s_resize_) || !defined(_di_f_uint8ss_append_) || !defined(_di_f_uint8ss_append_all_)
/**
* @see f_uint8ss_decimate_by()
*/
#if !defined(_di_f_uint8ss_adjust_) || !defined(_di_f_uint8ss_decimate_by_)
- extern f_status_t private_f_uint8ss_adjust(const f_number_unsigned_t length, f_uint8ss_t *uint8ss) F_attribute_visibility_internal_d;
+ extern f_status_t private_f_uint8ss_adjust(const f_number_unsigned_t length, f_uint8ss_t * const uint8ss) F_attribute_visibility_internal_d;
#endif // !defined(_di_f_uint8ss_adjust_) || !defined(_di_f_uint8ss_decimate_by_)
/**
* @see f_uint8ss_resize()
*/
#if !defined(_di_f_uint8ss_decrease_by_) || !defined(_di_f_uint8ss_increase_) || !defined(_di_f_uint8ss_increase_by_) || !defined(_di_f_uint8ss_resize_)
- extern f_status_t private_f_uint8ss_resize(const f_number_unsigned_t length, f_uint8ss_t *uint8ss) F_attribute_visibility_internal_d;
+ extern f_status_t private_f_uint8ss_resize(const f_number_unsigned_t length, f_uint8ss_t * const uint8ss) F_attribute_visibility_internal_d;
#endif // !defined(_di_f_uint8ss_decrease_by_) || !defined(_di_f_uint8ss_increase_) || !defined(_di_f_uint8ss_increase_by_) || !defined(_di_f_uint8ss_resize_)
#ifdef __cplusplus
#endif
#ifndef _di_f_states_adjust_
- f_status_t f_states_adjust(const f_number_unsigned_t length, f_states_t *states) {
+ f_status_t f_states_adjust(const f_number_unsigned_t length, f_states_t * const states) {
#ifndef _di_level_0_parameter_checking_
if (!states) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_states_adjust_
#ifndef _di_f_states_append_
- f_status_t f_states_append(const f_state_t source, f_states_t *destination) {
+ f_status_t f_states_append(const f_state_t source, f_states_t * const destination) {
#ifndef _di_level_0_parameter_checking_
if (!destination) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_states_append_
#ifndef _di_f_states_append_all_
- f_status_t f_states_append_all(const f_states_t source, f_states_t *destination) {
+ f_status_t f_states_append_all(const f_states_t source, f_states_t * const destination) {
#ifndef _di_level_0_parameter_checking_
if (!destination) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_states_append_all_
#ifndef _di_f_states_decimate_by_
- f_status_t f_states_decimate_by(const f_number_unsigned_t amount, f_states_t *states) {
+ f_status_t f_states_decimate_by(const f_number_unsigned_t amount, f_states_t * const states) {
#ifndef _di_level_0_parameter_checking_
if (!states) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_states_decimate_by_
#ifndef _di_f_states_decrease_by_
- f_status_t f_states_decrease_by(const f_number_unsigned_t amount, f_states_t *states) {
+ f_status_t f_states_decrease_by(const f_number_unsigned_t amount, f_states_t * const states) {
#ifndef _di_level_0_parameter_checking_
if (!states) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_states_decrease_by_
#ifndef _di_f_states_increase_
- f_status_t f_states_increase(const f_number_unsigned_t step, f_states_t *states) {
+ f_status_t f_states_increase(const f_number_unsigned_t step, f_states_t * const states) {
#ifndef _di_level_0_parameter_checking_
if (!states) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_states_increase_
#ifndef _di_f_states_increase_by_
- f_status_t f_states_increase_by(const f_number_unsigned_t amount, f_states_t *states) {
+ f_status_t f_states_increase_by(const f_number_unsigned_t amount, f_states_t * const states) {
#ifndef _di_level_0_parameter_checking_
if (!states) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_states_increase_by_
#ifndef _di_f_states_resize_
- f_status_t f_states_resize(const f_number_unsigned_t length, f_states_t *states) {
+ f_status_t f_states_resize(const f_number_unsigned_t length, f_states_t * const states) {
#ifndef _di_level_0_parameter_checking_
if (!states) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_states_resize_
#ifndef _di_f_statess_adjust_
- f_status_t f_statess_adjust(const f_number_unsigned_t length, f_statess_t *statess) {
+ f_status_t f_statess_adjust(const f_number_unsigned_t length, f_statess_t * const statess) {
#ifndef _di_level_0_parameter_checking_
if (!statess) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_statess_adjust_
#ifndef _di_f_statess_append_
- f_status_t f_statess_append(const f_states_t source, f_statess_t *destination) {
+ f_status_t f_statess_append(const f_states_t source, f_statess_t * const destination) {
#ifndef _di_level_0_parameter_checking_
if (!destination) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_statess_append_
#ifndef _di_f_statess_append_all_
- f_status_t f_statess_append_all(const f_statess_t source, f_statess_t *destination) {
+ f_status_t f_statess_append_all(const f_statess_t source, f_statess_t * const destination) {
#ifndef _di_level_0_parameter_checking_
if (!destination) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_statess_append_all_
#ifndef _di_f_statess_decimate_by_
- f_status_t f_statess_decimate_by(const f_number_unsigned_t amount, f_statess_t *statess) {
+ f_status_t f_statess_decimate_by(const f_number_unsigned_t amount, f_statess_t * const statess) {
#ifndef _di_level_0_parameter_checking_
if (!statess) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_statess_decimate_by_
#ifndef _di_f_statess_decrease_by_
- f_status_t f_statess_decrease_by(const f_number_unsigned_t amount, f_statess_t *statess) {
+ f_status_t f_statess_decrease_by(const f_number_unsigned_t amount, f_statess_t * const statess) {
#ifndef _di_level_0_parameter_checking_
if (!statess) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_statess_decrease_by_
#ifndef _di_f_statess_increase_
- f_status_t f_statess_increase(const f_number_unsigned_t step, f_statess_t *statess) {
+ f_status_t f_statess_increase(const f_number_unsigned_t step, f_statess_t * const statess) {
#ifndef _di_level_0_parameter_checking_
if (!statess) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_statess_increase_
#ifndef _di_f_statess_increase_by_
- f_status_t f_statess_increase_by(const f_number_unsigned_t amount, f_statess_t *statess) {
+ f_status_t f_statess_increase_by(const f_number_unsigned_t amount, f_statess_t * const statess) {
#ifndef _di_level_0_parameter_checking_
if (!statess) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_statess_increase_by_
#ifndef _di_f_statess_resize_
- f_status_t f_statess_resize(const f_number_unsigned_t length, f_statess_t *statess) {
+ f_status_t f_statess_resize(const f_number_unsigned_t length, f_statess_t * const statess) {
#ifndef _di_level_0_parameter_checking_
if (!statess) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
* Errors (with error bit) from: f_memory_adjust().
*/
#ifndef _di_f_states_adjust_
- extern f_status_t f_states_adjust(const f_number_unsigned_t length, f_states_t *states);
+ extern f_status_t f_states_adjust(const f_number_unsigned_t length, f_states_t * const states);
#endif // _di_f_states_adjust_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_states_append_
- extern f_status_t f_states_append(const f_state_t source, f_states_t *destination);
+ extern f_status_t f_states_append(const f_state_t source, f_states_t * const destination);
#endif // _di_f_states_append_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_states_append_all_
- extern f_status_t f_states_append_all(const f_states_t source, f_states_t *destination);
+ extern f_status_t f_states_append_all(const f_states_t source, f_states_t * const destination);
#endif // _di_f_states_append_all_
/**
* Errors (with error bit) from: f_memory_adjust().
*/
#ifndef _di_f_states_decimate_by_
- extern f_status_t f_states_decimate_by(const f_number_unsigned_t amount, f_states_t *states);
+ extern f_status_t f_states_decimate_by(const f_number_unsigned_t amount, f_states_t * const states);
#endif // _di_f_states_decimate_by_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_states_decrease_by_
- extern f_status_t f_states_decrease_by(const f_number_unsigned_t amount, f_states_t *states);
+ extern f_status_t f_states_decrease_by(const f_number_unsigned_t amount, f_states_t * const states);
#endif // _di_f_states_decrease_by_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_states_increase_
- extern f_status_t f_states_increase(const f_number_unsigned_t step, f_states_t *states);
+ extern f_status_t f_states_increase(const f_number_unsigned_t step, f_states_t * const states);
#endif // _di_f_states_increase_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_states_increase_by_
- extern f_status_t f_states_increase_by(const f_number_unsigned_t amount, f_states_t *states);
+ extern f_status_t f_states_increase_by(const f_number_unsigned_t amount, f_states_t * const states);
#endif // _di_f_states_increase_by_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_states_resize_
- extern f_status_t f_states_resize(const f_number_unsigned_t length, f_states_t *states);
+ extern f_status_t f_states_resize(const f_number_unsigned_t length, f_states_t * const states);
#endif // _di_f_states_resize_
/**
* Errors (with error bit) from: f_memory_destroy().
*/
#ifndef _di_f_statess_adjust_
- extern f_status_t f_statess_adjust(const f_number_unsigned_t length, f_statess_t *statess);
+ extern f_status_t f_statess_adjust(const f_number_unsigned_t length, f_statess_t * const statess);
#endif // _di_f_statess_adjust_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_statess_append_
- extern f_status_t f_statess_append(const f_states_t source, f_statess_t *destination);
+ extern f_status_t f_statess_append(const f_states_t source, f_statess_t * const destination);
#endif // _di_f_statess_append_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_statess_append_all_
- extern f_status_t f_statess_append_all(const f_statess_t source, f_statess_t *destination);
+ extern f_status_t f_statess_append_all(const f_statess_t source, f_statess_t * const destination);
#endif // _di_f_statess_append_all_
/**
* Errors (with error bit) from: f_memory_destroy().
*/
#ifndef _di_f_statess_decimate_by_
- extern f_status_t f_statess_decimate_by(const f_number_unsigned_t amount, f_statess_t *statess);
+ extern f_status_t f_statess_decimate_by(const f_number_unsigned_t amount, f_statess_t * const statess);
#endif // _di_f_statess_decimate_by_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_statess_decrease_by_
- extern f_status_t f_statess_decrease_by(const f_number_unsigned_t amount, f_statess_t *statess);
+ extern f_status_t f_statess_decrease_by(const f_number_unsigned_t amount, f_statess_t * const statess);
#endif // _di_f_statess_decrease_by_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_statess_increase_
- extern f_status_t f_statess_increase(const f_number_unsigned_t step, f_statess_t *statess);
+ extern f_status_t f_statess_increase(const f_number_unsigned_t step, f_statess_t * const statess);
#endif // _di_f_statess_increase_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_statess_increase_by_
- extern f_status_t f_statess_increase_by(const f_number_unsigned_t amount, f_statess_t *statess);
+ extern f_status_t f_statess_increase_by(const f_number_unsigned_t amount, f_statess_t * const statess);
#endif // _di_f_statess_increase_by_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_statess_resize_
- extern f_status_t f_statess_resize(const f_number_unsigned_t length, f_statess_t *statess);
+ extern f_status_t f_statess_resize(const f_number_unsigned_t length, f_statess_t * const statess);
#endif // _di_f_statess_resize_
#ifdef __cplusplus
#endif
#ifndef _di_f_statuss_adjust_
- f_status_t f_statuss_adjust(const f_number_unsigned_t length, f_statuss_t *statuss) {
+ f_status_t f_statuss_adjust(const f_number_unsigned_t length, f_statuss_t * const statuss) {
#ifndef _di_level_0_parameter_checking_
if (!statuss) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_statuss_adjust_
#ifndef _di_f_statuss_append_
- f_status_t f_statuss_append(const f_status_t source, f_statuss_t *destination) {
+ f_status_t f_statuss_append(const f_status_t source, f_statuss_t * const destination) {
#ifndef _di_level_0_parameter_checking_
if (!destination) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_statuss_append_
#ifndef _di_f_statuss_append_all_
- f_status_t f_statuss_append_all(const f_statuss_t source, f_statuss_t *destination) {
+ f_status_t f_statuss_append_all(const f_statuss_t source, f_statuss_t * const destination) {
#ifndef _di_level_0_parameter_checking_
if (!destination) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_statuss_append_all_
#ifndef _di_f_statuss_decimate_by_
- f_status_t f_statuss_decimate_by(const f_number_unsigned_t amount, f_statuss_t *statuss) {
+ f_status_t f_statuss_decimate_by(const f_number_unsigned_t amount, f_statuss_t * const statuss) {
#ifndef _di_level_0_parameter_checking_
if (!statuss) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_statuss_decimate_by_
#ifndef _di_f_statuss_decrease_by_
- f_status_t f_statuss_decrease_by(const f_number_unsigned_t amount, f_statuss_t *statuss) {
+ f_status_t f_statuss_decrease_by(const f_number_unsigned_t amount, f_statuss_t * const statuss) {
#ifndef _di_level_0_parameter_checking_
if (!statuss) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_statuss_decrease_by_
#ifndef _di_f_statuss_increase_
- f_status_t f_statuss_increase(const f_number_unsigned_t step, f_statuss_t *statuss) {
+ f_status_t f_statuss_increase(const f_number_unsigned_t step, f_statuss_t * const statuss) {
#ifndef _di_level_0_parameter_checking_
if (!statuss) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_statuss_increase_
#ifndef _di_f_statuss_increase_by_
- f_status_t f_statuss_increase_by(const f_number_unsigned_t amount, f_statuss_t *statuss) {
+ f_status_t f_statuss_increase_by(const f_number_unsigned_t amount, f_statuss_t * const statuss) {
#ifndef _di_level_0_parameter_checking_
if (!statuss) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_statuss_increase_by_
#ifndef _di_f_statuss_resize_
- f_status_t f_statuss_resize(const f_number_unsigned_t length, f_statuss_t *statuss) {
+ f_status_t f_statuss_resize(const f_number_unsigned_t length, f_statuss_t * const statuss) {
#ifndef _di_level_0_parameter_checking_
if (!statuss) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_statuss_resize_
#ifndef _di_f_statusss_adjust_
- f_status_t f_statusss_adjust(const f_number_unsigned_t length, f_statusss_t *statusss) {
+ f_status_t f_statusss_adjust(const f_number_unsigned_t length, f_statusss_t * const statusss) {
#ifndef _di_level_0_parameter_checking_
if (!statusss) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_statusss_adjust_
#ifndef _di_f_statusss_append_
- f_status_t f_statusss_append(const f_statuss_t source, f_statusss_t *destination) {
+ f_status_t f_statusss_append(const f_statuss_t source, f_statusss_t * const destination) {
#ifndef _di_level_0_parameter_checking_
if (!destination) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_statusss_append_
#ifndef _di_f_statusss_append_all_
- f_status_t f_statusss_append_all(const f_statusss_t source, f_statusss_t *destination) {
+ f_status_t f_statusss_append_all(const f_statusss_t source, f_statusss_t * const destination) {
#ifndef _di_level_0_parameter_checking_
if (!destination) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_statusss_append_all_
#ifndef _di_f_statusss_decimate_by_
- f_status_t f_statusss_decimate_by(const f_number_unsigned_t amount, f_statusss_t *statusss) {
+ f_status_t f_statusss_decimate_by(const f_number_unsigned_t amount, f_statusss_t * const statusss) {
#ifndef _di_level_0_parameter_checking_
if (!statusss) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_statusss_decimate_by_
#ifndef _di_f_statusss_decrease_by_
- f_status_t f_statusss_decrease_by(const f_number_unsigned_t amount, f_statusss_t *statusss) {
+ f_status_t f_statusss_decrease_by(const f_number_unsigned_t amount, f_statusss_t * const statusss) {
#ifndef _di_level_0_parameter_checking_
if (!statusss) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_statusss_decrease_by_
#ifndef _di_f_statusss_increase_
- f_status_t f_statusss_increase(const f_number_unsigned_t step, f_statusss_t *statusss) {
+ f_status_t f_statusss_increase(const f_number_unsigned_t step, f_statusss_t * const statusss) {
#ifndef _di_level_0_parameter_checking_
if (!statusss) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_statusss_increase_
#ifndef _di_f_statusss_increase_by_
- f_status_t f_statusss_increase_by(const f_number_unsigned_t amount, f_statusss_t *statusss) {
+ f_status_t f_statusss_increase_by(const f_number_unsigned_t amount, f_statusss_t * const statusss) {
#ifndef _di_level_0_parameter_checking_
if (!statusss) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_statusss_increase_by_
#ifndef _di_f_statusss_resize_
- f_status_t f_statusss_resize(const f_number_unsigned_t length, f_statusss_t *statusss) {
+ f_status_t f_statusss_resize(const f_number_unsigned_t length, f_statusss_t * const statusss) {
#ifndef _di_level_0_parameter_checking_
if (!statusss) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
* Errors (with error bit) from: f_memory_adjust().
*/
#ifndef _di_f_statuss_adjust_
- extern f_status_t f_statuss_adjust(const f_number_unsigned_t length, f_statuss_t *statuss);
+ extern f_status_t f_statuss_adjust(const f_number_unsigned_t length, f_statuss_t * const statuss);
#endif // _di_f_statuss_adjust_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_statuss_append_
- extern f_status_t f_statuss_append(const f_status_t source, f_statuss_t *destination);
+ extern f_status_t f_statuss_append(const f_status_t source, f_statuss_t * const destination);
#endif // _di_f_statuss_append_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_statuss_append_all_
- extern f_status_t f_statuss_append_all(const f_statuss_t source, f_statuss_t *destination);
+ extern f_status_t f_statuss_append_all(const f_statuss_t source, f_statuss_t * const destination);
#endif // _di_f_statuss_append_all_
/**
* Errors (with error bit) from: f_memory_adjust().
*/
#ifndef _di_f_statuss_decimate_by_
- extern f_status_t f_statuss_decimate_by(const f_number_unsigned_t amount, f_statuss_t *statuss);
+ extern f_status_t f_statuss_decimate_by(const f_number_unsigned_t amount, f_statuss_t * const statuss);
#endif // _di_f_statuss_decimate_by_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_statuss_decrease_by_
- extern f_status_t f_statuss_decrease_by(const f_number_unsigned_t amount, f_statuss_t *statuss);
+ extern f_status_t f_statuss_decrease_by(const f_number_unsigned_t amount, f_statuss_t * const statuss);
#endif // _di_f_statuss_decrease_by_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_statuss_increase_
- extern f_status_t f_statuss_increase(const f_number_unsigned_t step, f_statuss_t *statuss);
+ extern f_status_t f_statuss_increase(const f_number_unsigned_t step, f_statuss_t * const statuss);
#endif // _di_f_statuss_increase_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_statuss_increase_by_
- extern f_status_t f_statuss_increase_by(const f_number_unsigned_t amount, f_statuss_t *statuss);
+ extern f_status_t f_statuss_increase_by(const f_number_unsigned_t amount, f_statuss_t * const statuss);
#endif // _di_f_statuss_increase_by_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_statuss_resize_
- extern f_status_t f_statuss_resize(const f_number_unsigned_t length, f_statuss_t *statuss);
+ extern f_status_t f_statuss_resize(const f_number_unsigned_t length, f_statuss_t * const statuss);
#endif // _di_f_statuss_resize_
/**
* Errors (with error bit) from: f_memory_destroy().
*/
#ifndef _di_f_statusss_adjust_
- extern f_status_t f_statusss_adjust(const f_number_unsigned_t length, f_statusss_t *statusss);
+ extern f_status_t f_statusss_adjust(const f_number_unsigned_t length, f_statusss_t * const statusss);
#endif // _di_f_statusss_adjust_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_statusss_append_
- extern f_status_t f_statusss_append(const f_statuss_t source, f_statusss_t *destination);
+ extern f_status_t f_statusss_append(const f_statuss_t source, f_statusss_t * const destination);
#endif // _di_f_statusss_append_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_statusss_append_all_
- extern f_status_t f_statusss_append_all(const f_statusss_t source, f_statusss_t *destination);
+ extern f_status_t f_statusss_append_all(const f_statusss_t source, f_statusss_t * const destination);
#endif // _di_f_statusss_append_all_
/**
* Errors (with error bit) from: f_memory_destroy().
*/
#ifndef _di_f_statusss_decimate_by_
- extern f_status_t f_statusss_decimate_by(const f_number_unsigned_t amount, f_statusss_t *statusss);
+ extern f_status_t f_statusss_decimate_by(const f_number_unsigned_t amount, f_statusss_t * const statusss);
#endif // _di_f_statusss_decimate_by_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_statusss_decrease_by_
- extern f_status_t f_statusss_decrease_by(const f_number_unsigned_t amount, f_statusss_t *statusss);
+ extern f_status_t f_statusss_decrease_by(const f_number_unsigned_t amount, f_statusss_t * const statusss);
#endif // _di_f_statusss_decrease_by_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_statusss_increase_
- extern f_status_t f_statusss_increase(const f_number_unsigned_t step, f_statusss_t *statusss);
+ extern f_status_t f_statusss_increase(const f_number_unsigned_t step, f_statusss_t * const statusss);
#endif // _di_f_statusss_increase_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_statusss_increase_by_
- extern f_status_t f_statusss_increase_by(const f_number_unsigned_t amount, f_statusss_t *statusss);
+ extern f_status_t f_statusss_increase_by(const f_number_unsigned_t amount, f_statusss_t * const statusss);
#endif // _di_f_statusss_increase_by_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_statusss_resize_
- extern f_status_t f_statusss_resize(const f_number_unsigned_t length, f_statusss_t *statusss);
+ extern f_status_t f_statusss_resize(const f_number_unsigned_t length, f_statusss_t * const statusss);
#endif // _di_f_statusss_resize_
#ifdef __cplusplus
#endif
#ifndef _di_f_uint128s_adjust_
- f_status_t f_uint128s_adjust(const f_number_unsigned_t length, f_uint128s_t *uint128s) {
+ f_status_t f_uint128s_adjust(const f_number_unsigned_t length, f_uint128s_t * const uint128s) {
#ifndef _di_level_0_parameter_checking_
if (!uint128s) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_uint128s_adjust_
#ifndef _di_f_uint128s_append_
- f_status_t f_uint128s_append(const uint128_t source, f_uint128s_t *destination) {
+ f_status_t f_uint128s_append(const uint128_t source, f_uint128s_t * const destination) {
#ifndef _di_level_0_parameter_checking_
if (!destination) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_uint128s_append_
#ifndef _di_f_uint128s_append_all_
- f_status_t f_uint128s_append_all(const f_uint128s_t source, f_uint128s_t *destination) {
+ f_status_t f_uint128s_append_all(const f_uint128s_t source, f_uint128s_t * const destination) {
#ifndef _di_level_0_parameter_checking_
if (!destination) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_uint128s_append_all_
#ifndef _di_f_uint128s_decimate_by_
- f_status_t f_uint128s_decimate_by(const f_number_unsigned_t amount, f_uint128s_t *uint128s) {
+ f_status_t f_uint128s_decimate_by(const f_number_unsigned_t amount, f_uint128s_t * const uint128s) {
#ifndef _di_level_0_parameter_checking_
if (!uint128s) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_uint128s_decimate_by_
#ifndef _di_f_uint128s_decrease_by_
- f_status_t f_uint128s_decrease_by(const f_number_unsigned_t amount, f_uint128s_t *uint128s) {
+ f_status_t f_uint128s_decrease_by(const f_number_unsigned_t amount, f_uint128s_t * const uint128s) {
#ifndef _di_level_0_parameter_checking_
if (!uint128s) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_uint128s_decrease_by_
#ifndef _di_f_uint128s_increase_
- f_status_t f_uint128s_increase(const f_number_unsigned_t step, f_uint128s_t *uint128s) {
+ f_status_t f_uint128s_increase(const f_number_unsigned_t step, f_uint128s_t * const uint128s) {
#ifndef _di_level_0_parameter_checking_
if (!uint128s) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_uint128s_increase_
#ifndef _di_f_uint128s_increase_by_
- f_status_t f_uint128s_increase_by(const f_number_unsigned_t amount, f_uint128s_t *uint128s) {
+ f_status_t f_uint128s_increase_by(const f_number_unsigned_t amount, f_uint128s_t * const uint128s) {
#ifndef _di_level_0_parameter_checking_
if (!uint128s) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_uint128s_increase_by_
#ifndef _di_f_uint128s_resize_
- f_status_t f_uint128s_resize(const f_number_unsigned_t length, f_uint128s_t *uint128s) {
+ f_status_t f_uint128s_resize(const f_number_unsigned_t length, f_uint128s_t * const uint128s) {
#ifndef _di_level_0_parameter_checking_
if (!uint128s) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_uint128s_resize_
#ifndef _di_f_uint128ss_adjust_
- f_status_t f_uint128ss_adjust(const f_number_unsigned_t length, f_uint128ss_t *uint128ss) {
+ f_status_t f_uint128ss_adjust(const f_number_unsigned_t length, f_uint128ss_t * const uint128ss) {
#ifndef _di_level_0_parameter_checking_
if (!uint128ss) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_uint128ss_adjust_
#ifndef _di_f_uint128ss_append_
- f_status_t f_uint128ss_append(const f_uint128s_t source, f_uint128ss_t *destination) {
+ f_status_t f_uint128ss_append(const f_uint128s_t source, f_uint128ss_t * const destination) {
#ifndef _di_level_0_parameter_checking_
if (!destination) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_uint128ss_append_
#ifndef _di_f_uint128ss_append_all_
- f_status_t f_uint128ss_append_all(const f_uint128ss_t source, f_uint128ss_t *destination) {
+ f_status_t f_uint128ss_append_all(const f_uint128ss_t source, f_uint128ss_t * const destination) {
#ifndef _di_level_0_parameter_checking_
if (!destination) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_uint128ss_append_all_
#ifndef _di_f_uint128ss_decimate_by_
- f_status_t f_uint128ss_decimate_by(const f_number_unsigned_t amount, f_uint128ss_t *uint128ss) {
+ f_status_t f_uint128ss_decimate_by(const f_number_unsigned_t amount, f_uint128ss_t * const uint128ss) {
#ifndef _di_level_0_parameter_checking_
if (!uint128ss) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_uint128ss_decimate_by_
#ifndef _di_f_uint128ss_decrease_by_
- f_status_t f_uint128ss_decrease_by(const f_number_unsigned_t amount, f_uint128ss_t *uint128ss) {
+ f_status_t f_uint128ss_decrease_by(const f_number_unsigned_t amount, f_uint128ss_t * const uint128ss) {
#ifndef _di_level_0_parameter_checking_
if (!uint128ss) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_uint128ss_decrease_by_
#ifndef _di_f_uint128ss_increase_
- f_status_t f_uint128ss_increase(const f_number_unsigned_t step, f_uint128ss_t *uint128ss) {
+ f_status_t f_uint128ss_increase(const f_number_unsigned_t step, f_uint128ss_t * const uint128ss) {
#ifndef _di_level_0_parameter_checking_
if (!uint128ss) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_uint128ss_increase_
#ifndef _di_f_uint128ss_increase_by_
- f_status_t f_uint128ss_increase_by(const f_number_unsigned_t amount, f_uint128ss_t *uint128ss) {
+ f_status_t f_uint128ss_increase_by(const f_number_unsigned_t amount, f_uint128ss_t * const uint128ss) {
#ifndef _di_level_0_parameter_checking_
if (!uint128ss) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_uint128ss_increase_by_
#ifndef _di_f_uint128ss_resize_
- f_status_t f_uint128ss_resize(const f_number_unsigned_t length, f_uint128ss_t *uint128ss) {
+ f_status_t f_uint128ss_resize(const f_number_unsigned_t length, f_uint128ss_t * const uint128ss) {
#ifndef _di_level_0_parameter_checking_
if (!uint128ss) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
* Errors (with error bit) from: f_memory_adjust().
*/
#ifndef _di_f_uint128s_adjust_
- extern f_status_t f_uint128s_adjust(const f_number_unsigned_t length, f_uint128s_t *uint128s);
+ extern f_status_t f_uint128s_adjust(const f_number_unsigned_t length, f_uint128s_t * const uint128s);
#endif // _di_f_uint128s_adjust_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_uint128s_append_
- extern f_status_t f_uint128s_append(const uint128_t source, f_uint128s_t *destination);
+ extern f_status_t f_uint128s_append(const uint128_t source, f_uint128s_t * const destination);
#endif // _di_f_uint128s_append_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_uint128s_append_all_
- extern f_status_t f_uint128s_append_all(const f_uint128s_t source, f_uint128s_t *destination);
+ extern f_status_t f_uint128s_append_all(const f_uint128s_t source, f_uint128s_t * const destination);
#endif // _di_f_uint128s_append_all_
/**
* Errors (with error bit) from: f_memory_adjust().
*/
#ifndef _di_f_uint128s_decimate_by_
- extern f_status_t f_uint128s_decimate_by(const f_number_unsigned_t amount, f_uint128s_t *uint128s);
+ extern f_status_t f_uint128s_decimate_by(const f_number_unsigned_t amount, f_uint128s_t * const uint128s);
#endif // _di_f_uint128s_decimate_by_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_uint128s_decrease_by_
- extern f_status_t f_uint128s_decrease_by(const f_number_unsigned_t amount, f_uint128s_t *uint128s);
+ extern f_status_t f_uint128s_decrease_by(const f_number_unsigned_t amount, f_uint128s_t * const uint128s);
#endif // _di_f_uint128s_decrease_by_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_uint128s_increase_
- extern f_status_t f_uint128s_increase(const f_number_unsigned_t step, f_uint128s_t *uint128s);
+ extern f_status_t f_uint128s_increase(const f_number_unsigned_t step, f_uint128s_t * const uint128s);
#endif // _di_f_uint128s_increase_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_uint128s_increase_by_
- extern f_status_t f_uint128s_increase_by(const f_number_unsigned_t amount, f_uint128s_t *uint128s);
+ extern f_status_t f_uint128s_increase_by(const f_number_unsigned_t amount, f_uint128s_t * const uint128s);
#endif // _di_f_uint128s_increase_by_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_uint128s_resize_
- extern f_status_t f_uint128s_resize(const f_number_unsigned_t length, f_uint128s_t *uint128s);
+ extern f_status_t f_uint128s_resize(const f_number_unsigned_t length, f_uint128s_t * const uint128s);
#endif // _di_f_uint128s_resize_
/**
* Errors (with error bit) from: f_memory_destroy().
*/
#ifndef _di_f_uint128ss_adjust_
- extern f_status_t f_uint128ss_adjust(const f_number_unsigned_t length, f_uint128ss_t *uint128ss);
+ extern f_status_t f_uint128ss_adjust(const f_number_unsigned_t length, f_uint128ss_t * const uint128ss);
#endif // _di_f_uint128ss_adjust_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_uint128ss_append_
- extern f_status_t f_uint128ss_append(const f_uint128s_t source, f_uint128ss_t *destination);
+ extern f_status_t f_uint128ss_append(const f_uint128s_t source, f_uint128ss_t * const destination);
#endif // _di_f_uint128ss_append_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_uint128ss_append_all_
- extern f_status_t f_uint128ss_append_all(const f_uint128ss_t source, f_uint128ss_t *destination);
+ extern f_status_t f_uint128ss_append_all(const f_uint128ss_t source, f_uint128ss_t * const destination);
#endif // _di_f_uint128ss_append_all_
/**
* Errors (with error bit) from: f_memory_destroy().
*/
#ifndef _di_f_uint128ss_decimate_by_
- extern f_status_t f_uint128ss_decimate_by(const f_number_unsigned_t amount, f_uint128ss_t *uint128ss);
+ extern f_status_t f_uint128ss_decimate_by(const f_number_unsigned_t amount, f_uint128ss_t * const uint128ss);
#endif // _di_f_uint128ss_decimate_by_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_uint128ss_decrease_by_
- extern f_status_t f_uint128ss_decrease_by(const f_number_unsigned_t amount, f_uint128ss_t *uint128ss);
+ extern f_status_t f_uint128ss_decrease_by(const f_number_unsigned_t amount, f_uint128ss_t * const uint128ss);
#endif // _di_f_uint128ss_decrease_by_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_uint128ss_increase_
- extern f_status_t f_uint128ss_increase(const f_number_unsigned_t step, f_uint128ss_t *uint128ss);
+ extern f_status_t f_uint128ss_increase(const f_number_unsigned_t step, f_uint128ss_t * const uint128ss);
#endif // _di_f_uint128ss_increase_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_uint128ss_increase_by_
- extern f_status_t f_uint128ss_increase_by(const f_number_unsigned_t amount, f_uint128ss_t *uint128ss);
+ extern f_status_t f_uint128ss_increase_by(const f_number_unsigned_t amount, f_uint128ss_t * const uint128ss);
#endif // _di_f_uint128ss_increase_by_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_uint128ss_resize_
- extern f_status_t f_uint128ss_resize(const f_number_unsigned_t length, f_uint128ss_t *uint128ss);
+ extern f_status_t f_uint128ss_resize(const f_number_unsigned_t length, f_uint128ss_t * const uint128ss);
#endif // _di_f_uint128ss_resize_
#ifdef __cplusplus
#endif
#ifndef _di_f_uint16s_adjust_
- f_status_t f_uint16s_adjust(const f_number_unsigned_t length, f_uint16s_t *uint16s) {
+ f_status_t f_uint16s_adjust(const f_number_unsigned_t length, f_uint16s_t * const uint16s) {
#ifndef _di_level_0_parameter_checking_
if (!uint16s) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_uint16s_adjust_
#ifndef _di_f_uint16s_append_
- f_status_t f_uint16s_append(const uint16_t source, f_uint16s_t *destination) {
+ f_status_t f_uint16s_append(const uint16_t source, f_uint16s_t * const destination) {
#ifndef _di_level_0_parameter_checking_
if (!destination) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_uint16s_append_
#ifndef _di_f_uint16s_append_all_
- f_status_t f_uint16s_append_all(const f_uint16s_t source, f_uint16s_t *destination) {
+ f_status_t f_uint16s_append_all(const f_uint16s_t source, f_uint16s_t * const destination) {
#ifndef _di_level_0_parameter_checking_
if (!destination) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_uint16s_append_all_
#ifndef _di_f_uint16s_decimate_by_
- f_status_t f_uint16s_decimate_by(const f_number_unsigned_t amount, f_uint16s_t *uint16s) {
+ f_status_t f_uint16s_decimate_by(const f_number_unsigned_t amount, f_uint16s_t * const uint16s) {
#ifndef _di_level_0_parameter_checking_
if (!uint16s) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_uint16s_decimate_by_
#ifndef _di_f_uint16s_decrease_by_
- f_status_t f_uint16s_decrease_by(const f_number_unsigned_t amount, f_uint16s_t *uint16s) {
+ f_status_t f_uint16s_decrease_by(const f_number_unsigned_t amount, f_uint16s_t * const uint16s) {
#ifndef _di_level_0_parameter_checking_
if (!uint16s) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_uint16s_decrease_by_
#ifndef _di_f_uint16s_increase_
- f_status_t f_uint16s_increase(const f_number_unsigned_t step, f_uint16s_t *uint16s) {
+ f_status_t f_uint16s_increase(const f_number_unsigned_t step, f_uint16s_t * const uint16s) {
#ifndef _di_level_0_parameter_checking_
if (!uint16s) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_uint16s_increase_
#ifndef _di_f_uint16s_increase_by_
- f_status_t f_uint16s_increase_by(const f_number_unsigned_t amount, f_uint16s_t *uint16s) {
+ f_status_t f_uint16s_increase_by(const f_number_unsigned_t amount, f_uint16s_t * const uint16s) {
#ifndef _di_level_0_parameter_checking_
if (!uint16s) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_uint16s_increase_by_
#ifndef _di_f_uint16s_resize_
- f_status_t f_uint16s_resize(const f_number_unsigned_t length, f_uint16s_t *uint16s) {
+ f_status_t f_uint16s_resize(const f_number_unsigned_t length, f_uint16s_t * const uint16s) {
#ifndef _di_level_0_parameter_checking_
if (!uint16s) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_uint16s_resize_
#ifndef _di_f_uint16ss_adjust_
- f_status_t f_uint16ss_adjust(const f_number_unsigned_t length, f_uint16ss_t *uint16ss) {
+ f_status_t f_uint16ss_adjust(const f_number_unsigned_t length, f_uint16ss_t * const uint16ss) {
#ifndef _di_level_0_parameter_checking_
if (!uint16ss) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_uint16ss_adjust_
#ifndef _di_f_uint16ss_append_
- f_status_t f_uint16ss_append(const f_uint16s_t source, f_uint16ss_t *destination) {
+ f_status_t f_uint16ss_append(const f_uint16s_t source, f_uint16ss_t * const destination) {
#ifndef _di_level_0_parameter_checking_
if (!destination) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_uint16ss_append_
#ifndef _di_f_uint16ss_append_all_
- f_status_t f_uint16ss_append_all(const f_uint16ss_t source, f_uint16ss_t *destination) {
+ f_status_t f_uint16ss_append_all(const f_uint16ss_t source, f_uint16ss_t * const destination) {
#ifndef _di_level_0_parameter_checking_
if (!destination) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_uint16ss_append_all_
#ifndef _di_f_uint16ss_decimate_by_
- f_status_t f_uint16ss_decimate_by(const f_number_unsigned_t amount, f_uint16ss_t *uint16ss) {
+ f_status_t f_uint16ss_decimate_by(const f_number_unsigned_t amount, f_uint16ss_t * const uint16ss) {
#ifndef _di_level_0_parameter_checking_
if (!uint16ss) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_uint16ss_decimate_by_
#ifndef _di_f_uint16ss_decrease_by_
- f_status_t f_uint16ss_decrease_by(const f_number_unsigned_t amount, f_uint16ss_t *uint16ss) {
+ f_status_t f_uint16ss_decrease_by(const f_number_unsigned_t amount, f_uint16ss_t * const uint16ss) {
#ifndef _di_level_0_parameter_checking_
if (!uint16ss) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_uint16ss_decrease_by_
#ifndef _di_f_uint16ss_increase_
- f_status_t f_uint16ss_increase(const f_number_unsigned_t step, f_uint16ss_t *uint16ss) {
+ f_status_t f_uint16ss_increase(const f_number_unsigned_t step, f_uint16ss_t * const uint16ss) {
#ifndef _di_level_0_parameter_checking_
if (!uint16ss) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_uint16ss_increase_
#ifndef _di_f_uint16ss_increase_by_
- f_status_t f_uint16ss_increase_by(const f_number_unsigned_t amount, f_uint16ss_t *uint16ss) {
+ f_status_t f_uint16ss_increase_by(const f_number_unsigned_t amount, f_uint16ss_t * const uint16ss) {
#ifndef _di_level_0_parameter_checking_
if (!uint16ss) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_uint16ss_increase_by_
#ifndef _di_f_uint16ss_resize_
- f_status_t f_uint16ss_resize(const f_number_unsigned_t length, f_uint16ss_t *uint16ss) {
+ f_status_t f_uint16ss_resize(const f_number_unsigned_t length, f_uint16ss_t * const uint16ss) {
#ifndef _di_level_0_parameter_checking_
if (!uint16ss) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
* Errors (with error bit) from: f_memory_adjust().
*/
#ifndef _di_f_uint16s_adjust_
- extern f_status_t f_uint16s_adjust(const f_number_unsigned_t length, f_uint16s_t *uint16s);
+ extern f_status_t f_uint16s_adjust(const f_number_unsigned_t length, f_uint16s_t * const uint16s);
#endif // _di_f_uint16s_adjust_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_uint16s_append_
- extern f_status_t f_uint16s_append(const uint16_t source, f_uint16s_t *destination);
+ extern f_status_t f_uint16s_append(const uint16_t source, f_uint16s_t * const destination);
#endif // _di_f_uint16s_append_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_uint16s_append_all_
- extern f_status_t f_uint16s_append_all(const f_uint16s_t source, f_uint16s_t *destination);
+ extern f_status_t f_uint16s_append_all(const f_uint16s_t source, f_uint16s_t * const destination);
#endif // _di_f_uint16s_append_all_
/**
* Errors (with error bit) from: f_memory_adjust().
*/
#ifndef _di_f_uint16s_decimate_by_
- extern f_status_t f_uint16s_decimate_by(const f_number_unsigned_t amount, f_uint16s_t *uint16s);
+ extern f_status_t f_uint16s_decimate_by(const f_number_unsigned_t amount, f_uint16s_t * const uint16s);
#endif // _di_f_uint16s_decimate_by_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_uint16s_decrease_by_
- extern f_status_t f_uint16s_decrease_by(const f_number_unsigned_t amount, f_uint16s_t *uint16s);
+ extern f_status_t f_uint16s_decrease_by(const f_number_unsigned_t amount, f_uint16s_t * const uint16s);
#endif // _di_f_uint16s_decrease_by_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_uint16s_increase_
- extern f_status_t f_uint16s_increase(const f_number_unsigned_t step, f_uint16s_t *uint16s);
+ extern f_status_t f_uint16s_increase(const f_number_unsigned_t step, f_uint16s_t * const uint16s);
#endif // _di_f_uint16s_increase_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_uint16s_increase_by_
- extern f_status_t f_uint16s_increase_by(const f_number_unsigned_t amount, f_uint16s_t *uint16s);
+ extern f_status_t f_uint16s_increase_by(const f_number_unsigned_t amount, f_uint16s_t * const uint16s);
#endif // _di_f_uint16s_increase_by_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_uint16s_resize_
- extern f_status_t f_uint16s_resize(const f_number_unsigned_t length, f_uint16s_t *uint16s);
+ extern f_status_t f_uint16s_resize(const f_number_unsigned_t length, f_uint16s_t * const uint16s);
#endif // _di_f_uint16s_resize_
/**
* Errors (with error bit) from: f_memory_destroy().
*/
#ifndef _di_f_uint16ss_adjust_
- extern f_status_t f_uint16ss_adjust(const f_number_unsigned_t length, f_uint16ss_t *uint16ss);
+ extern f_status_t f_uint16ss_adjust(const f_number_unsigned_t length, f_uint16ss_t * const uint16ss);
#endif // _di_f_uint16ss_adjust_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_uint16ss_append_
- extern f_status_t f_uint16ss_append(const f_uint16s_t source, f_uint16ss_t *destination);
+ extern f_status_t f_uint16ss_append(const f_uint16s_t source, f_uint16ss_t * const destination);
#endif // _di_f_uint16ss_append_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_uint16ss_append_all_
- extern f_status_t f_uint16ss_append_all(const f_uint16ss_t source, f_uint16ss_t *destination);
+ extern f_status_t f_uint16ss_append_all(const f_uint16ss_t source, f_uint16ss_t * const destination);
#endif // _di_f_uint16ss_append_all_
/**
* Errors (with error bit) from: f_memory_destroy().
*/
#ifndef _di_f_uint16ss_decimate_by_
- extern f_status_t f_uint16ss_decimate_by(const f_number_unsigned_t amount, f_uint16ss_t *uint16ss);
+ extern f_status_t f_uint16ss_decimate_by(const f_number_unsigned_t amount, f_uint16ss_t * const uint16ss);
#endif // _di_f_uint16ss_decimate_by_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_uint16ss_decrease_by_
- extern f_status_t f_uint16ss_decrease_by(const f_number_unsigned_t amount, f_uint16ss_t *uint16ss);
+ extern f_status_t f_uint16ss_decrease_by(const f_number_unsigned_t amount, f_uint16ss_t * const uint16ss);
#endif // _di_f_uint16ss_decrease_by_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_uint16ss_increase_
- extern f_status_t f_uint16ss_increase(const f_number_unsigned_t step, f_uint16ss_t *uint16ss);
+ extern f_status_t f_uint16ss_increase(const f_number_unsigned_t step, f_uint16ss_t * const uint16ss);
#endif // _di_f_uint16ss_increase_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_uint16ss_increase_by_
- extern f_status_t f_uint16ss_increase_by(const f_number_unsigned_t amount, f_uint16ss_t *uint16ss);
+ extern f_status_t f_uint16ss_increase_by(const f_number_unsigned_t amount, f_uint16ss_t * const uint16ss);
#endif // _di_f_uint16ss_increase_by_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_uint16ss_resize_
- extern f_status_t f_uint16ss_resize(const f_number_unsigned_t length, f_uint16ss_t *uint16ss);
+ extern f_status_t f_uint16ss_resize(const f_number_unsigned_t length, f_uint16ss_t * const uint16ss);
#endif // _di_f_uint16ss_resize_
#ifdef __cplusplus
#endif
#ifndef _di_f_uint32s_adjust_
- f_status_t f_uint32s_adjust(const f_number_unsigned_t length, f_uint32s_t *uint32s) {
+ f_status_t f_uint32s_adjust(const f_number_unsigned_t length, f_uint32s_t * const uint32s) {
#ifndef _di_level_0_parameter_checking_
if (!uint32s) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_uint32s_adjust_
#ifndef _di_f_uint32s_append_
- f_status_t f_uint32s_append(const uint32_t source, f_uint32s_t *destination) {
+ f_status_t f_uint32s_append(const uint32_t source, f_uint32s_t * const destination) {
#ifndef _di_level_0_parameter_checking_
if (!destination) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_uint32s_append_
#ifndef _di_f_uint32s_append_all_
- f_status_t f_uint32s_append_all(const f_uint32s_t source, f_uint32s_t *destination) {
+ f_status_t f_uint32s_append_all(const f_uint32s_t source, f_uint32s_t * const destination) {
#ifndef _di_level_0_parameter_checking_
if (!destination) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_uint32s_append_all_
#ifndef _di_f_uint32s_decimate_by_
- f_status_t f_uint32s_decimate_by(const f_number_unsigned_t amount, f_uint32s_t *uint32s) {
+ f_status_t f_uint32s_decimate_by(const f_number_unsigned_t amount, f_uint32s_t * const uint32s) {
#ifndef _di_level_0_parameter_checking_
if (!uint32s) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_uint32s_decimate_by_
#ifndef _di_f_uint32s_decrease_by_
- f_status_t f_uint32s_decrease_by(const f_number_unsigned_t amount, f_uint32s_t *uint32s) {
+ f_status_t f_uint32s_decrease_by(const f_number_unsigned_t amount, f_uint32s_t * const uint32s) {
#ifndef _di_level_0_parameter_checking_
if (!uint32s) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_uint32s_decrease_by_
#ifndef _di_f_uint32s_increase_
- f_status_t f_uint32s_increase(const f_number_unsigned_t step, f_uint32s_t *uint32s) {
+ f_status_t f_uint32s_increase(const f_number_unsigned_t step, f_uint32s_t * const uint32s) {
#ifndef _di_level_0_parameter_checking_
if (!uint32s) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_uint32s_increase_
#ifndef _di_f_uint32s_increase_by_
- f_status_t f_uint32s_increase_by(const f_number_unsigned_t amount, f_uint32s_t *uint32s) {
+ f_status_t f_uint32s_increase_by(const f_number_unsigned_t amount, f_uint32s_t * const uint32s) {
#ifndef _di_level_0_parameter_checking_
if (!uint32s) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_uint32s_increase_by_
#ifndef _di_f_uint32s_resize_
- f_status_t f_uint32s_resize(const f_number_unsigned_t length, f_uint32s_t *uint32s) {
+ f_status_t f_uint32s_resize(const f_number_unsigned_t length, f_uint32s_t * const uint32s) {
#ifndef _di_level_0_parameter_checking_
if (!uint32s) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_uint32s_resize_
#ifndef _di_f_uint32ss_adjust_
- f_status_t f_uint32ss_adjust(const f_number_unsigned_t length, f_uint32ss_t *uint32ss) {
+ f_status_t f_uint32ss_adjust(const f_number_unsigned_t length, f_uint32ss_t * const uint32ss) {
#ifndef _di_level_0_parameter_checking_
if (!uint32ss) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_uint32ss_adjust_
#ifndef _di_f_uint32ss_append_
- f_status_t f_uint32ss_append(const f_uint32s_t source, f_uint32ss_t *destination) {
+ f_status_t f_uint32ss_append(const f_uint32s_t source, f_uint32ss_t * const destination) {
#ifndef _di_level_0_parameter_checking_
if (!destination) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_uint32ss_append_
#ifndef _di_f_uint32ss_append_all_
- f_status_t f_uint32ss_append_all(const f_uint32ss_t source, f_uint32ss_t *destination) {
+ f_status_t f_uint32ss_append_all(const f_uint32ss_t source, f_uint32ss_t * const destination) {
#ifndef _di_level_0_parameter_checking_
if (!destination) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_uint32ss_append_all_
#ifndef _di_f_uint32ss_decimate_by_
- f_status_t f_uint32ss_decimate_by(const f_number_unsigned_t amount, f_uint32ss_t *uint32ss) {
+ f_status_t f_uint32ss_decimate_by(const f_number_unsigned_t amount, f_uint32ss_t * const uint32ss) {
#ifndef _di_level_0_parameter_checking_
if (!uint32ss) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_uint32ss_decimate_by_
#ifndef _di_f_uint32ss_decrease_by_
- f_status_t f_uint32ss_decrease_by(const f_number_unsigned_t amount, f_uint32ss_t *uint32ss) {
+ f_status_t f_uint32ss_decrease_by(const f_number_unsigned_t amount, f_uint32ss_t * const uint32ss) {
#ifndef _di_level_0_parameter_checking_
if (!uint32ss) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_uint32ss_decrease_by_
#ifndef _di_f_uint32ss_increase_
- f_status_t f_uint32ss_increase(const f_number_unsigned_t step, f_uint32ss_t *uint32ss) {
+ f_status_t f_uint32ss_increase(const f_number_unsigned_t step, f_uint32ss_t * const uint32ss) {
#ifndef _di_level_0_parameter_checking_
if (!uint32ss) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_uint32ss_increase_
#ifndef _di_f_uint32ss_increase_by_
- f_status_t f_uint32ss_increase_by(const f_number_unsigned_t amount, f_uint32ss_t *uint32ss) {
+ f_status_t f_uint32ss_increase_by(const f_number_unsigned_t amount, f_uint32ss_t * const uint32ss) {
#ifndef _di_level_0_parameter_checking_
if (!uint32ss) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_uint32ss_increase_by_
#ifndef _di_f_uint32ss_resize_
- f_status_t f_uint32ss_resize(const f_number_unsigned_t length, f_uint32ss_t *uint32ss) {
+ f_status_t f_uint32ss_resize(const f_number_unsigned_t length, f_uint32ss_t * const uint32ss) {
#ifndef _di_level_0_parameter_checking_
if (!uint32ss) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
* Errors (with error bit) from: f_memory_adjust().
*/
#ifndef _di_f_uint32s_adjust_
- extern f_status_t f_uint32s_adjust(const f_number_unsigned_t length, f_uint32s_t *uint32s);
+ extern f_status_t f_uint32s_adjust(const f_number_unsigned_t length, f_uint32s_t * const uint32s);
#endif // _di_f_uint32s_adjust_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_uint32s_append_
- extern f_status_t f_uint32s_append(const uint32_t source, f_uint32s_t *destination);
+ extern f_status_t f_uint32s_append(const uint32_t source, f_uint32s_t * const destination);
#endif // _di_f_uint32s_append_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_uint32s_append_all_
- extern f_status_t f_uint32s_append_all(const f_uint32s_t source, f_uint32s_t *destination);
+ extern f_status_t f_uint32s_append_all(const f_uint32s_t source, f_uint32s_t * const destination);
#endif // _di_f_uint32s_append_all_
/**
* Errors (with error bit) from: f_memory_adjust().
*/
#ifndef _di_f_uint32s_decimate_by_
- extern f_status_t f_uint32s_decimate_by(const f_number_unsigned_t amount, f_uint32s_t *uint32s);
+ extern f_status_t f_uint32s_decimate_by(const f_number_unsigned_t amount, f_uint32s_t * const uint32s);
#endif // _di_f_uint32s_decimate_by_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_uint32s_decrease_by_
- extern f_status_t f_uint32s_decrease_by(const f_number_unsigned_t amount, f_uint32s_t *uint32s);
+ extern f_status_t f_uint32s_decrease_by(const f_number_unsigned_t amount, f_uint32s_t * const uint32s);
#endif // _di_f_uint32s_decrease_by_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_uint32s_increase_
- extern f_status_t f_uint32s_increase(const f_number_unsigned_t step, f_uint32s_t *uint32s);
+ extern f_status_t f_uint32s_increase(const f_number_unsigned_t step, f_uint32s_t * const uint32s);
#endif // _di_f_uint32s_increase_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_uint32s_increase_by_
- extern f_status_t f_uint32s_increase_by(const f_number_unsigned_t amount, f_uint32s_t *uint32s);
+ extern f_status_t f_uint32s_increase_by(const f_number_unsigned_t amount, f_uint32s_t * const uint32s);
#endif // _di_f_uint32s_increase_by_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_uint32s_resize_
- extern f_status_t f_uint32s_resize(const f_number_unsigned_t length, f_uint32s_t *uint32s);
+ extern f_status_t f_uint32s_resize(const f_number_unsigned_t length, f_uint32s_t * const uint32s);
#endif // _di_f_uint32s_resize_
/**
* Errors (with error bit) from: f_memory_destroy().
*/
#ifndef _di_f_uint32ss_adjust_
- extern f_status_t f_uint32ss_adjust(const f_number_unsigned_t length, f_uint32ss_t *uint32ss);
+ extern f_status_t f_uint32ss_adjust(const f_number_unsigned_t length, f_uint32ss_t * const uint32ss);
#endif // _di_f_uint32ss_adjust_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_uint32ss_append_
- extern f_status_t f_uint32ss_append(const f_uint32s_t source, f_uint32ss_t *destination);
+ extern f_status_t f_uint32ss_append(const f_uint32s_t source, f_uint32ss_t * const destination);
#endif // _di_f_uint32ss_append_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_uint32ss_append_all_
- extern f_status_t f_uint32ss_append_all(const f_uint32ss_t source, f_uint32ss_t *destination);
+ extern f_status_t f_uint32ss_append_all(const f_uint32ss_t source, f_uint32ss_t * const destination);
#endif // _di_f_uint32ss_append_all_
/**
* Errors (with error bit) from: f_memory_destroy().
*/
#ifndef _di_f_uint32ss_decimate_by_
- extern f_status_t f_uint32ss_decimate_by(const f_number_unsigned_t amount, f_uint32ss_t *uint32ss);
+ extern f_status_t f_uint32ss_decimate_by(const f_number_unsigned_t amount, f_uint32ss_t * const uint32ss);
#endif // _di_f_uint32ss_decimate_by_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_uint32ss_decrease_by_
- extern f_status_t f_uint32ss_decrease_by(const f_number_unsigned_t amount, f_uint32ss_t *uint32ss);
+ extern f_status_t f_uint32ss_decrease_by(const f_number_unsigned_t amount, f_uint32ss_t * const uint32ss);
#endif // _di_f_uint32ss_decrease_by_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_uint32ss_increase_
- extern f_status_t f_uint32ss_increase(const f_number_unsigned_t step, f_uint32ss_t *uint32ss);
+ extern f_status_t f_uint32ss_increase(const f_number_unsigned_t step, f_uint32ss_t * const uint32ss);
#endif // _di_f_uint32ss_increase_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_uint32ss_increase_by_
- extern f_status_t f_uint32ss_increase_by(const f_number_unsigned_t amount, f_uint32ss_t *uint32ss);
+ extern f_status_t f_uint32ss_increase_by(const f_number_unsigned_t amount, f_uint32ss_t * const uint32ss);
#endif // _di_f_uint32ss_increase_by_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_uint32ss_resize_
- extern f_status_t f_uint32ss_resize(const f_number_unsigned_t length, f_uint32ss_t *uint32ss);
+ extern f_status_t f_uint32ss_resize(const f_number_unsigned_t length, f_uint32ss_t * const uint32ss);
#endif // _di_f_uint32ss_resize_
#ifdef __cplusplus
#endif
#ifndef _di_f_uint64s_adjust_
- f_status_t f_uint64s_adjust(const f_number_unsigned_t length, f_uint64s_t *uint64s) {
+ f_status_t f_uint64s_adjust(const f_number_unsigned_t length, f_uint64s_t * const uint64s) {
#ifndef _di_level_0_parameter_checking_
if (!uint64s) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_uint64s_adjust_
#ifndef _di_f_uint64s_append_
- f_status_t f_uint64s_append(const uint64_t source, f_uint64s_t *destination) {
+ f_status_t f_uint64s_append(const uint64_t source, f_uint64s_t * const destination) {
#ifndef _di_level_0_parameter_checking_
if (!destination) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_uint64s_append_
#ifndef _di_f_uint64s_append_all_
- f_status_t f_uint64s_append_all(const f_uint64s_t source, f_uint64s_t *destination) {
+ f_status_t f_uint64s_append_all(const f_uint64s_t source, f_uint64s_t * const destination) {
#ifndef _di_level_0_parameter_checking_
if (!destination) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_uint64s_append_all_
#ifndef _di_f_uint64s_decimate_by_
- f_status_t f_uint64s_decimate_by(const f_number_unsigned_t amount, f_uint64s_t *uint64s) {
+ f_status_t f_uint64s_decimate_by(const f_number_unsigned_t amount, f_uint64s_t * const uint64s) {
#ifndef _di_level_0_parameter_checking_
if (!uint64s) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_uint64s_decimate_by_
#ifndef _di_f_uint64s_decrease_by_
- f_status_t f_uint64s_decrease_by(const f_number_unsigned_t amount, f_uint64s_t *uint64s) {
+ f_status_t f_uint64s_decrease_by(const f_number_unsigned_t amount, f_uint64s_t * const uint64s) {
#ifndef _di_level_0_parameter_checking_
if (!uint64s) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_uint64s_decrease_by_
#ifndef _di_f_uint64s_increase_
- f_status_t f_uint64s_increase(const f_number_unsigned_t step, f_uint64s_t *uint64s) {
+ f_status_t f_uint64s_increase(const f_number_unsigned_t step, f_uint64s_t * const uint64s) {
#ifndef _di_level_0_parameter_checking_
if (!uint64s) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_uint64s_increase_
#ifndef _di_f_uint64s_increase_by_
- f_status_t f_uint64s_increase_by(const f_number_unsigned_t amount, f_uint64s_t *uint64s) {
+ f_status_t f_uint64s_increase_by(const f_number_unsigned_t amount, f_uint64s_t * const uint64s) {
#ifndef _di_level_0_parameter_checking_
if (!uint64s) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_uint64s_increase_by_
#ifndef _di_f_uint64s_resize_
- f_status_t f_uint64s_resize(const f_number_unsigned_t length, f_uint64s_t *uint64s) {
+ f_status_t f_uint64s_resize(const f_number_unsigned_t length, f_uint64s_t * const uint64s) {
#ifndef _di_level_0_parameter_checking_
if (!uint64s) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_uint64s_resize_
#ifndef _di_f_uint64ss_adjust_
- f_status_t f_uint64ss_adjust(const f_number_unsigned_t length, f_uint64ss_t *uint64ss) {
+ f_status_t f_uint64ss_adjust(const f_number_unsigned_t length, f_uint64ss_t * const uint64ss) {
#ifndef _di_level_0_parameter_checking_
if (!uint64ss) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_uint64ss_adjust_
#ifndef _di_f_uint64ss_append_
- f_status_t f_uint64ss_append(const f_uint64s_t source, f_uint64ss_t *destination) {
+ f_status_t f_uint64ss_append(const f_uint64s_t source, f_uint64ss_t * const destination) {
#ifndef _di_level_0_parameter_checking_
if (!destination) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_uint64ss_append_
#ifndef _di_f_uint64ss_append_all_
- f_status_t f_uint64ss_append_all(const f_uint64ss_t source, f_uint64ss_t *destination) {
+ f_status_t f_uint64ss_append_all(const f_uint64ss_t source, f_uint64ss_t * const destination) {
#ifndef _di_level_0_parameter_checking_
if (!destination) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_uint64ss_append_all_
#ifndef _di_f_uint64ss_decimate_by_
- f_status_t f_uint64ss_decimate_by(const f_number_unsigned_t amount, f_uint64ss_t *uint64ss) {
+ f_status_t f_uint64ss_decimate_by(const f_number_unsigned_t amount, f_uint64ss_t * const uint64ss) {
#ifndef _di_level_0_parameter_checking_
if (!uint64ss) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_uint64ss_decimate_by_
#ifndef _di_f_uint64ss_decrease_by_
- f_status_t f_uint64ss_decrease_by(const f_number_unsigned_t amount, f_uint64ss_t *uint64ss) {
+ f_status_t f_uint64ss_decrease_by(const f_number_unsigned_t amount, f_uint64ss_t * const uint64ss) {
#ifndef _di_level_0_parameter_checking_
if (!uint64ss) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_uint64ss_decrease_by_
#ifndef _di_f_uint64ss_increase_
- f_status_t f_uint64ss_increase(const f_number_unsigned_t step, f_uint64ss_t *uint64ss) {
+ f_status_t f_uint64ss_increase(const f_number_unsigned_t step, f_uint64ss_t * const uint64ss) {
#ifndef _di_level_0_parameter_checking_
if (!uint64ss) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_uint64ss_increase_
#ifndef _di_f_uint64ss_increase_by_
- f_status_t f_uint64ss_increase_by(const f_number_unsigned_t amount, f_uint64ss_t *uint64ss) {
+ f_status_t f_uint64ss_increase_by(const f_number_unsigned_t amount, f_uint64ss_t * const uint64ss) {
#ifndef _di_level_0_parameter_checking_
if (!uint64ss) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_uint64ss_increase_by_
#ifndef _di_f_uint64ss_resize_
- f_status_t f_uint64ss_resize(const f_number_unsigned_t length, f_uint64ss_t *uint64ss) {
+ f_status_t f_uint64ss_resize(const f_number_unsigned_t length, f_uint64ss_t * const uint64ss) {
#ifndef _di_level_0_parameter_checking_
if (!uint64ss) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
* Errors (with error bit) from: f_memory_adjust().
*/
#ifndef _di_f_uint64s_adjust_
- extern f_status_t f_uint64s_adjust(const f_number_unsigned_t length, f_uint64s_t *uint64s);
+ extern f_status_t f_uint64s_adjust(const f_number_unsigned_t length, f_uint64s_t * const uint64s);
#endif // _di_f_uint64s_adjust_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_uint64s_append_
- extern f_status_t f_uint64s_append(const uint64_t source, f_uint64s_t *destination);
+ extern f_status_t f_uint64s_append(const uint64_t source, f_uint64s_t * const destination);
#endif // _di_f_uint64s_append_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_uint64s_append_all_
- extern f_status_t f_uint64s_append_all(const f_uint64s_t source, f_uint64s_t *destination);
+ extern f_status_t f_uint64s_append_all(const f_uint64s_t source, f_uint64s_t * const destination);
#endif // _di_f_uint64s_append_all_
/**
* Errors (with error bit) from: f_memory_adjust().
*/
#ifndef _di_f_uint64s_decimate_by_
- extern f_status_t f_uint64s_decimate_by(const f_number_unsigned_t amount, f_uint64s_t *uint64s);
+ extern f_status_t f_uint64s_decimate_by(const f_number_unsigned_t amount, f_uint64s_t * const uint64s);
#endif // _di_f_uint64s_decimate_by_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_uint64s_decrease_by_
- extern f_status_t f_uint64s_decrease_by(const f_number_unsigned_t amount, f_uint64s_t *uint64s);
+ extern f_status_t f_uint64s_decrease_by(const f_number_unsigned_t amount, f_uint64s_t * const uint64s);
#endif // _di_f_uint64s_decrease_by_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_uint64s_increase_
- extern f_status_t f_uint64s_increase(const f_number_unsigned_t step, f_uint64s_t *uint64s);
+ extern f_status_t f_uint64s_increase(const f_number_unsigned_t step, f_uint64s_t * const uint64s);
#endif // _di_f_uint64s_increase_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_uint64s_increase_by_
- extern f_status_t f_uint64s_increase_by(const f_number_unsigned_t amount, f_uint64s_t *uint64s);
+ extern f_status_t f_uint64s_increase_by(const f_number_unsigned_t amount, f_uint64s_t * const uint64s);
#endif // _di_f_uint64s_increase_by_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_uint64s_resize_
- extern f_status_t f_uint64s_resize(const f_number_unsigned_t length, f_uint64s_t *uint64s);
+ extern f_status_t f_uint64s_resize(const f_number_unsigned_t length, f_uint64s_t * const uint64s);
#endif // _di_f_uint64s_resize_
/**
* Errors (with error bit) from: f_memory_destroy().
*/
#ifndef _di_f_uint64ss_adjust_
- extern f_status_t f_uint64ss_adjust(const f_number_unsigned_t length, f_uint64ss_t *uint64ss);
+ extern f_status_t f_uint64ss_adjust(const f_number_unsigned_t length, f_uint64ss_t * const uint64ss);
#endif // _di_f_uint64ss_adjust_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_uint64ss_append_
- extern f_status_t f_uint64ss_append(const f_uint64s_t source, f_uint64ss_t *destination);
+ extern f_status_t f_uint64ss_append(const f_uint64s_t source, f_uint64ss_t * const destination);
#endif // _di_f_uint64ss_append_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_uint64ss_append_all_
- extern f_status_t f_uint64ss_append_all(const f_uint64ss_t source, f_uint64ss_t *destination);
+ extern f_status_t f_uint64ss_append_all(const f_uint64ss_t source, f_uint64ss_t * const destination);
#endif // _di_f_uint64ss_append_all_
/**
* Errors (with error bit) from: f_memory_destroy().
*/
#ifndef _di_f_uint64ss_decimate_by_
- extern f_status_t f_uint64ss_decimate_by(const f_number_unsigned_t amount, f_uint64ss_t *uint64ss);
+ extern f_status_t f_uint64ss_decimate_by(const f_number_unsigned_t amount, f_uint64ss_t * const uint64ss);
#endif // _di_f_uint64ss_decimate_by_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_uint64ss_decrease_by_
- extern f_status_t f_uint64ss_decrease_by(const f_number_unsigned_t amount, f_uint64ss_t *uint64ss);
+ extern f_status_t f_uint64ss_decrease_by(const f_number_unsigned_t amount, f_uint64ss_t * const uint64ss);
#endif // _di_f_uint64ss_decrease_by_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_uint64ss_increase_
- extern f_status_t f_uint64ss_increase(const f_number_unsigned_t step, f_uint64ss_t *uint64ss);
+ extern f_status_t f_uint64ss_increase(const f_number_unsigned_t step, f_uint64ss_t * const uint64ss);
#endif // _di_f_uint64ss_increase_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_uint64ss_increase_by_
- extern f_status_t f_uint64ss_increase_by(const f_number_unsigned_t amount, f_uint64ss_t *uint64ss);
+ extern f_status_t f_uint64ss_increase_by(const f_number_unsigned_t amount, f_uint64ss_t * const uint64ss);
#endif // _di_f_uint64ss_increase_by_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_uint64ss_resize_
- extern f_status_t f_uint64ss_resize(const f_number_unsigned_t length, f_uint64ss_t *uint64ss);
+ extern f_status_t f_uint64ss_resize(const f_number_unsigned_t length, f_uint64ss_t * const uint64ss);
#endif // _di_f_uint64ss_resize_
#ifdef __cplusplus
#endif
#ifndef _di_f_uint8s_adjust_
- f_status_t f_uint8s_adjust(const f_number_unsigned_t length, f_uint8s_t *uint8s) {
+ f_status_t f_uint8s_adjust(const f_number_unsigned_t length, f_uint8s_t * const uint8s) {
#ifndef _di_level_0_parameter_checking_
if (!uint8s) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_uint8s_adjust_
#ifndef _di_f_uint8s_append_
- f_status_t f_uint8s_append(const uint8_t source, f_uint8s_t *destination) {
+ f_status_t f_uint8s_append(const uint8_t source, f_uint8s_t * const destination) {
#ifndef _di_level_0_parameter_checking_
if (!destination) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_uint8s_append_
#ifndef _di_f_uint8s_append_all_
- f_status_t f_uint8s_append_all(const f_uint8s_t source, f_uint8s_t *destination) {
+ f_status_t f_uint8s_append_all(const f_uint8s_t source, f_uint8s_t * const destination) {
#ifndef _di_level_0_parameter_checking_
if (!destination) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_uint8s_append_all_
#ifndef _di_f_uint8s_decimate_by_
- f_status_t f_uint8s_decimate_by(const f_number_unsigned_t amount, f_uint8s_t *uint8s) {
+ f_status_t f_uint8s_decimate_by(const f_number_unsigned_t amount, f_uint8s_t * const uint8s) {
#ifndef _di_level_0_parameter_checking_
if (!uint8s) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_uint8s_decimate_by_
#ifndef _di_f_uint8s_decrease_by_
- f_status_t f_uint8s_decrease_by(const f_number_unsigned_t amount, f_uint8s_t *uint8s) {
+ f_status_t f_uint8s_decrease_by(const f_number_unsigned_t amount, f_uint8s_t * const uint8s) {
#ifndef _di_level_0_parameter_checking_
if (!uint8s) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_uint8s_decrease_by_
#ifndef _di_f_uint8s_increase_
- f_status_t f_uint8s_increase(const f_number_unsigned_t step, f_uint8s_t *uint8s) {
+ f_status_t f_uint8s_increase(const f_number_unsigned_t step, f_uint8s_t * const uint8s) {
#ifndef _di_level_0_parameter_checking_
if (!uint8s) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_uint8s_increase_
#ifndef _di_f_uint8s_increase_by_
- f_status_t f_uint8s_increase_by(const f_number_unsigned_t amount, f_uint8s_t *uint8s) {
+ f_status_t f_uint8s_increase_by(const f_number_unsigned_t amount, f_uint8s_t * const uint8s) {
#ifndef _di_level_0_parameter_checking_
if (!uint8s) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_uint8s_increase_by_
#ifndef _di_f_uint8s_resize_
- f_status_t f_uint8s_resize(const f_number_unsigned_t length, f_uint8s_t *uint8s) {
+ f_status_t f_uint8s_resize(const f_number_unsigned_t length, f_uint8s_t * const uint8s) {
#ifndef _di_level_0_parameter_checking_
if (!uint8s) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_uint8s_resize_
#ifndef _di_f_uint8ss_adjust_
- f_status_t f_uint8ss_adjust(const f_number_unsigned_t length, f_uint8ss_t *uint8ss) {
+ f_status_t f_uint8ss_adjust(const f_number_unsigned_t length, f_uint8ss_t * const uint8ss) {
#ifndef _di_level_0_parameter_checking_
if (!uint8ss) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_uint8ss_adjust_
#ifndef _di_f_uint8ss_append_
- f_status_t f_uint8ss_append(const f_uint8s_t source, f_uint8ss_t *destination) {
+ f_status_t f_uint8ss_append(const f_uint8s_t source, f_uint8ss_t * const destination) {
#ifndef _di_level_0_parameter_checking_
if (!destination) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_uint8ss_append_
#ifndef _di_f_uint8ss_append_all_
- f_status_t f_uint8ss_append_all(const f_uint8ss_t source, f_uint8ss_t *destination) {
+ f_status_t f_uint8ss_append_all(const f_uint8ss_t source, f_uint8ss_t * const destination) {
#ifndef _di_level_0_parameter_checking_
if (!destination) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_uint8ss_append_all_
#ifndef _di_f_uint8ss_decimate_by_
- f_status_t f_uint8ss_decimate_by(const f_number_unsigned_t amount, f_uint8ss_t *uint8ss) {
+ f_status_t f_uint8ss_decimate_by(const f_number_unsigned_t amount, f_uint8ss_t * const uint8ss) {
#ifndef _di_level_0_parameter_checking_
if (!uint8ss) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_uint8ss_decimate_by_
#ifndef _di_f_uint8ss_decrease_by_
- f_status_t f_uint8ss_decrease_by(const f_number_unsigned_t amount, f_uint8ss_t *uint8ss) {
+ f_status_t f_uint8ss_decrease_by(const f_number_unsigned_t amount, f_uint8ss_t * const uint8ss) {
#ifndef _di_level_0_parameter_checking_
if (!uint8ss) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_uint8ss_decrease_by_
#ifndef _di_f_uint8ss_increase_
- f_status_t f_uint8ss_increase(const f_number_unsigned_t step, f_uint8ss_t *uint8ss) {
+ f_status_t f_uint8ss_increase(const f_number_unsigned_t step, f_uint8ss_t * const uint8ss) {
#ifndef _di_level_0_parameter_checking_
if (!uint8ss) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_uint8ss_increase_
#ifndef _di_f_uint8ss_increase_by_
- f_status_t f_uint8ss_increase_by(const f_number_unsigned_t amount, f_uint8ss_t *uint8ss) {
+ f_status_t f_uint8ss_increase_by(const f_number_unsigned_t amount, f_uint8ss_t * const uint8ss) {
#ifndef _di_level_0_parameter_checking_
if (!uint8ss) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
#endif // _di_f_uint8ss_increase_by_
#ifndef _di_f_uint8ss_resize_
- f_status_t f_uint8ss_resize(const f_number_unsigned_t length, f_uint8ss_t *uint8ss) {
+ f_status_t f_uint8ss_resize(const f_number_unsigned_t length, f_uint8ss_t * const uint8ss) {
#ifndef _di_level_0_parameter_checking_
if (!uint8ss) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
* Errors (with error bit) from: f_memory_adjust().
*/
#ifndef _di_f_uint8s_adjust_
- extern f_status_t f_uint8s_adjust(const f_number_unsigned_t length, f_uint8s_t *uint8s);
+ extern f_status_t f_uint8s_adjust(const f_number_unsigned_t length, f_uint8s_t * const uint8s);
#endif // _di_f_uint8s_adjust_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_uint8s_append_
- extern f_status_t f_uint8s_append(const uint8_t source, f_uint8s_t *destination);
+ extern f_status_t f_uint8s_append(const uint8_t source, f_uint8s_t * const destination);
#endif // _di_f_uint8s_append_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_uint8s_append_all_
- extern f_status_t f_uint8s_append_all(const f_uint8s_t source, f_uint8s_t *destination);
+ extern f_status_t f_uint8s_append_all(const f_uint8s_t source, f_uint8s_t * const destination);
#endif // _di_f_uint8s_append_all_
/**
* Errors (with error bit) from: f_memory_adjust().
*/
#ifndef _di_f_uint8s_decimate_by_
- extern f_status_t f_uint8s_decimate_by(const f_number_unsigned_t amount, f_uint8s_t *uint8s);
+ extern f_status_t f_uint8s_decimate_by(const f_number_unsigned_t amount, f_uint8s_t * const uint8s);
#endif // _di_f_uint8s_decimate_by_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_uint8s_decrease_by_
- extern f_status_t f_uint8s_decrease_by(const f_number_unsigned_t amount, f_uint8s_t *uint8s);
+ extern f_status_t f_uint8s_decrease_by(const f_number_unsigned_t amount, f_uint8s_t * const uint8s);
#endif // _di_f_uint8s_decrease_by_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_uint8s_increase_
- extern f_status_t f_uint8s_increase(const f_number_unsigned_t step, f_uint8s_t *uint8s);
+ extern f_status_t f_uint8s_increase(const f_number_unsigned_t step, f_uint8s_t * const uint8s);
#endif // _di_f_uint8s_increase_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_uint8s_increase_by_
- extern f_status_t f_uint8s_increase_by(const f_number_unsigned_t amount, f_uint8s_t *uint8s);
+ extern f_status_t f_uint8s_increase_by(const f_number_unsigned_t amount, f_uint8s_t * const uint8s);
#endif // _di_f_uint8s_increase_by_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_uint8s_resize_
- extern f_status_t f_uint8s_resize(const f_number_unsigned_t length, f_uint8s_t *uint8s);
+ extern f_status_t f_uint8s_resize(const f_number_unsigned_t length, f_uint8s_t * const uint8s);
#endif // _di_f_uint8s_resize_
/**
* Errors (with error bit) from: f_memory_destroy().
*/
#ifndef _di_f_uint8ss_adjust_
- extern f_status_t f_uint8ss_adjust(const f_number_unsigned_t length, f_uint8ss_t *uint8ss);
+ extern f_status_t f_uint8ss_adjust(const f_number_unsigned_t length, f_uint8ss_t * const uint8ss);
#endif // _di_f_uint8ss_adjust_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_uint8ss_append_
- extern f_status_t f_uint8ss_append(const f_uint8s_t source, f_uint8ss_t *destination);
+ extern f_status_t f_uint8ss_append(const f_uint8s_t source, f_uint8ss_t * const destination);
#endif // _di_f_uint8ss_append_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_uint8ss_append_all_
- extern f_status_t f_uint8ss_append_all(const f_uint8ss_t source, f_uint8ss_t *destination);
+ extern f_status_t f_uint8ss_append_all(const f_uint8ss_t source, f_uint8ss_t * const destination);
#endif // _di_f_uint8ss_append_all_
/**
* Errors (with error bit) from: f_memory_destroy().
*/
#ifndef _di_f_uint8ss_decimate_by_
- extern f_status_t f_uint8ss_decimate_by(const f_number_unsigned_t amount, f_uint8ss_t *uint8ss);
+ extern f_status_t f_uint8ss_decimate_by(const f_number_unsigned_t amount, f_uint8ss_t * const uint8ss);
#endif // _di_f_uint8ss_decimate_by_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_uint8ss_decrease_by_
- extern f_status_t f_uint8ss_decrease_by(const f_number_unsigned_t amount, f_uint8ss_t *uint8ss);
+ extern f_status_t f_uint8ss_decrease_by(const f_number_unsigned_t amount, f_uint8ss_t * const uint8ss);
#endif // _di_f_uint8ss_decrease_by_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_uint8ss_increase_
- extern f_status_t f_uint8ss_increase(const f_number_unsigned_t step, f_uint8ss_t *uint8ss);
+ extern f_status_t f_uint8ss_increase(const f_number_unsigned_t step, f_uint8ss_t * const uint8ss);
#endif // _di_f_uint8ss_increase_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_uint8ss_increase_by_
- extern f_status_t f_uint8ss_increase_by(const f_number_unsigned_t amount, f_uint8ss_t *uint8ss);
+ extern f_status_t f_uint8ss_increase_by(const f_number_unsigned_t amount, f_uint8ss_t * const uint8ss);
#endif // _di_f_uint8ss_increase_by_
/**
* Errors (with error bit) from: f_memory_resize().
*/
#ifndef _di_f_uint8ss_resize_
- extern f_status_t f_uint8ss_resize(const f_number_unsigned_t length, f_uint8ss_t *uint8ss);
+ extern f_status_t f_uint8ss_resize(const f_number_unsigned_t length, f_uint8ss_t * const uint8ss);
#endif // _di_f_uint8ss_resize_
#ifdef __cplusplus
projects / fll / commitdiff