The f_type_array project is really just an exception case extension of f_type.
It's purpose is to provide the array functions for the associated array structures in f_type.
These cannot be stored in f_type due to circular dependency needs for the f_memory project.
I used f_type_* to prefix these functions but the inconsistency between the structure names has shown to be a problem.
Rename these functions to not have the "_type" within them.
for (f_array_length_t i = 0; i < parameters->used; ++i) {
- status = f_type_array_lengths_resize(0, ¶meters->array[i].locations);
+ status = f_array_lengths_resize(0, ¶meters->array[i].locations);
if (F_status_is_error(status)) return status;
- status = f_type_array_lengths_resize(0, ¶meters->array[i].locations_sub);
+ status = f_array_lengths_resize(0, ¶meters->array[i].locations_sub);
if (F_status_is_error(status)) return status;
- status = f_type_array_lengths_resize(0, ¶meters->array[i].values);
+ status = f_array_lengths_resize(0, ¶meters->array[i].values);
if (F_status_is_error(status)) return status;
} // for
status = f_string_dynamics_resize(0, ¶meters->arguments);
if (F_status_is_error(status)) return status;
- status = f_type_array_lengths_resize(0, ¶meters->remaining);
+ status = f_array_lengths_resize(0, ¶meters->remaining);
if (F_status_is_error(status)) return status;
return F_none;
for (f_array_length_t i = 0; i < parameters->used; ++i) {
- status = f_type_array_lengths_adjust(0, ¶meters->array[i].locations);
+ status = f_array_lengths_adjust(0, ¶meters->array[i].locations);
if (F_status_is_error(status)) return status;
- status = f_type_array_lengths_adjust(0, ¶meters->array[i].locations_sub);
+ status = f_array_lengths_adjust(0, ¶meters->array[i].locations_sub);
if (F_status_is_error(status)) return status;
- status = f_type_array_lengths_adjust(0, ¶meters->array[i].values);
+ status = f_array_lengths_adjust(0, ¶meters->array[i].values);
if (F_status_is_error(status)) return status;
} // for
status = f_string_dynamics_adjust(0, ¶meters->arguments);
if (F_status_is_error(status)) return status;
- status = f_type_array_lengths_adjust(0, ¶meters->remaining);
+ status = f_array_lengths_adjust(0, ¶meters->remaining);
if (F_status_is_error(status)) return status;
return F_none;
* F_parameter (with error bit) if a parameter is invalid.
*
* Errors (with error bit) from: f_string_dynamics_resize().
- * Errors (with error bit) from: f_type_array_lengths_resize().
+ * Errors (with error bit) from: f_array_lengths_resize().
*
* @see f_string_dynamics_resize()
- * @see f_type_array_lengths_resize()
+ * @see f_array_lengths_resize()
*/
#ifndef _di_f_console_parameters_delete_
extern f_status_t f_console_parameters_delete(f_console_parameters_t * const parameters);
* F_parameter (with error bit) if a parameter is invalid.
*
* Errors (with error bit) from: f_string_dynamics_adjust().
- * Errors (with error bit) from: f_type_array_lengths_adjust().
+ * Errors (with error bit) from: f_array_lengths_adjust().
*
* @see f_string_dynamics_adjust()
- * @see f_type_array_lengths_adjust()
+ * @see f_array_lengths_adjust()
*/
#ifndef _di_f_console_parameters_destroy_
extern f_status_t f_console_parameters_destroy(f_console_parameters_t * const parameters);
if (needs_value.used > 0) {
i = needs_value.array[0];
- status = f_type_array_lengths_increase(F_memory_default_allocation_small_d, ¶meters->array[i].values);
+ status = f_array_lengths_increase(F_memory_default_allocation_small_d, ¶meters->array[i].values);
if (F_status_is_error(status)) break;
parameters->array[i].result = f_console_result_additional_e;
continue;
}
- status = f_type_array_lengths_increase(F_memory_default_allocation_small_d, ¶meters->array[i].locations);
+ status = f_array_lengths_increase(F_memory_default_allocation_small_d, ¶meters->array[i].locations);
if (F_status_is_error(status)) break;
- status = f_type_array_lengths_increase(F_memory_default_allocation_small_d, ¶meters->array[i].locations_sub);
+ status = f_array_lengths_increase(F_memory_default_allocation_small_d, ¶meters->array[i].locations_sub);
if (F_status_is_error(status)) break;
found = F_true;
if (parameters->array[i].values_total) {
if (needs_value.used + parameters->array[i].values_total > needs_value.size) {
- status = f_type_array_lengths_resize(needs_value.used + parameters->array[i].values_total, &needs_value);
+ status = f_array_lengths_resize(needs_value.used + parameters->array[i].values_total, &needs_value);
if (F_status_is_error(status)) break;
}
if (strncmp(arguments.argv[location], parameters->array[i].symbol_other, parameters->arguments.array[location].used + 1) != 0) continue;
- status = f_type_array_lengths_increase(F_memory_default_allocation_small_d, ¶meters->array[i].locations);
+ status = f_array_lengths_increase(F_memory_default_allocation_small_d, ¶meters->array[i].locations);
if (F_status_is_error(status)) break;
- status = f_type_array_lengths_increase(F_memory_default_allocation_small_d, ¶meters->array[i].locations_sub);
+ status = f_array_lengths_increase(F_memory_default_allocation_small_d, ¶meters->array[i].locations_sub);
if (F_status_is_error(status)) break;
parameters->array[i].locations.array[parameters->array[i].locations.used++] = location;
if (parameters->array[i].values_total) {
if (needs_value.used + parameters->array[i].values_total > needs_value.size) {
- status = f_type_array_lengths_resize(needs_value.used + parameters->array[i].values_total, &needs_value);
+ status = f_array_lengths_resize(needs_value.used + parameters->array[i].values_total, &needs_value);
if (F_status_is_error(status)) break;
}
if (!found) {
// Populate list of remaining parameters->array that are not associated with anything.
- status = f_type_array_lengths_increase(F_memory_default_allocation_small_d, ¶meters->remaining);
+ status = f_array_lengths_increase(F_memory_default_allocation_small_d, ¶meters->remaining);
if (F_status_is_error(status)) break;
parameters->remaining.array[parameters->remaining.used++] = location;
} // for
if (F_status_is_error(status)) {
- f_type_array_lengths_resize(0, &needs_value);
+ f_array_lengths_resize(0, &needs_value);
return status;
}
status = F_none;
}
- f_type_array_lengths_resize(0, &needs_value);
+ f_array_lengths_resize(0, &needs_value);
return status;
}
// This is a valid vocabulary name and content, but if it is delimited, save the delimit and ignore.
if (vocabulary_delimited) {
- status = f_type_array_lengths_increase(state.step_small, delimits);
+ status = f_array_lengths_increase(state.step_small, delimits);
if (F_status_is_error(status)) break;
delimits->array[delimits->used++] = vocabulary_slash_first;
++content_slash_delimits;
}
- status = f_type_array_lengths_increase_by(content_slash_delimits, delimits);
+ status = f_array_lengths_increase_by(content_slash_delimits, delimits);
if (F_status_is_error(status)) break;
content_range.start = content_slash_first;
// This is a valid vocabulary name and content, but if it is delimited, save the delimit and ignore.
if (vocabulary_delimited) {
- status = f_type_array_lengths_increase(state.step_small, delimits);
+ status = f_array_lengths_increase(state.step_small, delimits);
if (F_status_is_error(status)) break;
delimits->array[delimits->used++] = vocabulary_slash_first;
/**
* A status intended to be used as the return value status of some function or operation.
*/
-#ifndef _di_f_type_status_t_
+#ifndef _di_f_status_t_
typedef uint16_t f_status_t;
-#endif // _di_f_type_status_t_
+#endif // _di_f_status_t_
/**
* A representation of a state to be shared between different levels for some function.
* This should work in GCC, but other compilers this may not be available.
* When not supported, these will fallback to 64-bit.
*/
-#ifndef _di_f_type_int_128_t_
+#ifndef _di_f_int_128_t_
#ifdef __SIZEOF_INT128__
typedef __int128_t f_int_128_t;
typedef __uint128_t f_uint_128_t;
typedef int64_t f_int_128_t;
typedef uint64_t f_uint_128_t;
#endif // __SIZEOF_INT128__
-#endif // _di_f_type_int_128_t_
+#endif // _di_f_int_128_t_
/**
* Defines the maximum size to be supported.
#define F_type_size_64_positive_d 0x7ffffffffffffffe
#define F_type_size_64_unsigned_d 0xfffffffffffffffe
- #ifndef _di_f_type_int_128_t_
+ #ifndef _di_f_int_128_t_
#define F_type_size_128_negative_d 0x7fffffffffffffffffffffff
#define F_type_size_128_positive_d 0x7ffffffffffffffffffffffe
#define F_type_size_128_unsigned_d 0xfffffffffffffffffffffffe
#define F_type_size_128_negative_d F_type_size_64_negative_d
#define F_type_size_128_positive_d F_type_size_64_positive_d
#define F_type_size_128_unsigned_d F_type_size_64_unsigned_d
- #endif // _di_f_type_int_128_t_
+ #endif // _di_f_int_128_t_
#define F_type_size_max_8_negative_d 0x80
#define F_type_size_max_8_positive_d 0x7f
#define F_type_size_max_64_positive_d 0x7fffffffffffffff
#define F_type_size_max_64_unsigned_d 0xffffffffffffffff
- #ifndef _di_f_type_int_128_t_
+ #ifndef _di_f_int_128_t_
#define F_type_size_max_128_negative_d 0x800000000000000000000000
#define F_type_size_max_128_positive_d 0x7fffffffffffffffffffffff
#define F_type_size_max_128_unsigned_d 0xffffffffffffffffffffffff
#define F_type_size_max_128_negative_d F_type_size_max_64_negative_d
#define F_type_size_max_128_positive_d F_type_size_max_64_positive_d
#define F_type_size_max_128_unsigned_d F_type_size_max_64_unsigned_d
- #endif // _di_f_type_int_128_t_
+ #endif // _di_f_int_128_t_
#endif // _di_f_type_sizes_
/**
* size: Total amount of allocated space.
* used: Total number of allocated spaces used.
*/
-#ifndef _di_f_type_statuss_t_
+#ifndef _di_f_statuss_t_
typedef struct {
f_status_t *array;
} f_statuss_t;
#define f_statuss_t_initialize { 0, 0, 0 }
-#endif // _di_f_type_statuss_t_
+#endif // _di_f_statuss_t_
/**
* This holds an array of f_statuss_t.
* size: Total amount of allocated space.
* used: Total number of allocated spaces used.
*/
-#ifndef _di_f_type_statusss_t_
+#ifndef _di_f_statusss_t_
typedef struct {
f_statuss_t *array;
} f_statusss_t;
#define f_statusss_t_initialize { 0, 0, 0 }
-#endif // _di_f_type_statusss_t_
+#endif // _di_f_statusss_t_
/**
* This holds an array of f_state_t.
* size: Total amount of allocated space.
* used: Total number of allocated spaces used.
*/
-#ifndef _di_f_type_states_t_
+#ifndef _di_f_states_t_
typedef struct {
f_state_t *array;
} f_states_t;
#define f_states_t_initialize { 0, 0, 0 }
-#endif // _di_f_type_states_t_
+#endif // _di_f_states_t_
/**
* This holds an array of f_states_t.
* size: Total amount of allocated space.
* used: Total number of allocated spaces used.
*/
-#ifndef _di_f_type_statess_t_
+#ifndef _di_f_statess_t_
typedef struct {
f_states_t *array;
} f_statess_t;
#define f_statess_t_initialize { 0, 0, 0 }
-#endif // _di_f_type_statess_t_
+#endif // _di_f_statess_t_
/**
* An FLL Identifier represents a way to identify FLL related text files and possibly binary files.
#ifndef _di_f_statuss_t_
#define macro_f_statuss_t_clear(statuss) macro_f_memory_structures_clear(statuss)
- #define macro_f_statuss_t_resize(status, statuss, length) status = f_type_statuss_resize(length, &statuss);
- #define macro_f_statuss_t_adjust(status, statuss, length) status = f_type_statuss_adjust(length, &statuss);
+ #define macro_f_statuss_t_resize(status, statuss, length) status = f_statuss_resize(length, &statuss);
+ #define macro_f_statuss_t_adjust(status, statuss, length) status = f_statuss_adjust(length, &statuss);
- #define macro_f_statuss_t_delete_simple(statuss) f_type_statuss_resize(0, &statuss);
- #define macro_f_statuss_t_destroy_simple(statuss) f_type_statuss_adjust(0, &statuss);
+ #define macro_f_statuss_t_delete_simple(statuss) f_statuss_resize(0, &statuss);
+ #define macro_f_statuss_t_destroy_simple(statuss) f_statuss_adjust(0, &statuss);
- #define macro_f_statuss_t_increase(status, step, statuss) status = f_type_statuss_increase(step, &statuss);
- #define macro_f_statuss_t_increase_by(status, statuss, amount) status = f_type_statuss_increase_by(amount, &statuss);
- #define macro_f_statuss_t_decrease_by(status, statuss, amount) status = f_type_statuss_decrease_by(amount, &statuss);
- #define macro_f_statuss_t_decimate_by(status, statuss, amount) status = f_type_statuss_decimate_by(amount, &statuss);
+ #define macro_f_statuss_t_increase(status, step, statuss) status = f_statuss_increase(step, &statuss);
+ #define macro_f_statuss_t_increase_by(status, statuss, amount) status = f_statuss_increase_by(amount, &statuss);
+ #define macro_f_statuss_t_decrease_by(status, statuss, amount) status = f_statuss_decrease_by(amount, &statuss);
+ #define macro_f_statuss_t_decimate_by(status, statuss, amount) status = f_statuss_decimate_by(amount, &statuss);
#endif // _di_f_statuss_t_
/**
#ifndef _di_f_statusss_t_
#define macro_f_statusss_t_clear(statusss) macro_f_memory_structures_clear(statusss)
- #define macro_f_statusss_t_resize(status, statusss, length) status = f_type_statusss_resize(length, &statusss);
- #define macro_f_statusss_t_adjust(status, statusss, length) status = f_type_statusss_adjust(length, &statusss);
+ #define macro_f_statusss_t_resize(status, statusss, length) status = f_statusss_resize(length, &statusss);
+ #define macro_f_statusss_t_adjust(status, statusss, length) status = f_statusss_adjust(length, &statusss);
- #define macro_f_statusss_t_delete_simple(statusss) f_type_statusss_resize(0, &statusss);
- #define macro_f_statusss_t_destroy_simple(statusss) f_type_statusss_adjust(0, &statusss);
+ #define macro_f_statusss_t_delete_simple(statusss) f_statusss_resize(0, &statusss);
+ #define macro_f_statusss_t_destroy_simple(statusss) f_statusss_adjust(0, &statusss);
- #define macro_f_statusss_t_increase(status, step, statusss) status = f_type_statusss_increase(step, &statusss);
- #define macro_f_statusss_t_increase_by(status, statusss, amount) status = f_type_statusss_increase_by(amount, &statusss);
- #define macro_f_statusss_t_decrease_by(status, statusss, amount) status = f_type_statusss_decrease_by(amount, &statusss);
- #define macro_f_statusss_t_decimate_by(status, statusss, amount) status = f_type_statusss_decimate_by(amount, &statusss);
+ #define macro_f_statusss_t_increase(status, step, statusss) status = f_statusss_increase(step, &statusss);
+ #define macro_f_statusss_t_increase_by(status, statusss, amount) status = f_statusss_increase_by(amount, &statusss);
+ #define macro_f_statusss_t_decrease_by(status, statusss, amount) status = f_statusss_decrease_by(amount, &statusss);
+ #define macro_f_statusss_t_decimate_by(status, statusss, amount) status = f_statusss_decimate_by(amount, &statusss);
#endif // _di_f_statusss_t_
/**
#ifndef _di_f_states_t_
#define macro_f_states_t_clear(states) macro_f_memory_structures_clear(states)
- #define macro_f_states_t_resize(status, states, length) status = f_type_states_resize(length, &states);
- #define macro_f_states_t_adjust(status, states, length) status = f_type_states_adjust(length, &states);
+ #define macro_f_states_t_resize(status, states, length) status = f_states_resize(length, &states);
+ #define macro_f_states_t_adjust(status, states, length) status = f_states_adjust(length, &states);
- #define macro_f_states_t_delete_simple(states) f_type_states_resize(0, &states);
- #define macro_f_states_t_destroy_simple(states) f_type_states_adjust(0, &states);
+ #define macro_f_states_t_delete_simple(states) f_states_resize(0, &states);
+ #define macro_f_states_t_destroy_simple(states) f_states_adjust(0, &states);
- #define macro_f_states_t_increase(status, step, states) status = f_type_states_increase(step, &states);
- #define macro_f_states_t_increase_by(status, states, amount) status = f_type_states_increase_by(amount, &states);
- #define macro_f_states_t_decrease_by(status, states, amount) status = f_type_states_decrease_by(amount, &states);
- #define macro_f_states_t_decimate_by(status, states, amount) status = f_type_states_decimate_by(amount, &states);
+ #define macro_f_states_t_increase(status, step, states) status = f_states_increase(step, &states);
+ #define macro_f_states_t_increase_by(status, states, amount) status = f_states_increase_by(amount, &states);
+ #define macro_f_states_t_decrease_by(status, states, amount) status = f_states_decrease_by(amount, &states);
+ #define macro_f_states_t_decimate_by(status, states, amount) status = f_states_decimate_by(amount, &states);
#endif // _di_f_states_t_
/**
#ifndef _di_f_statess_t_
#define macro_f_statess_t_clear(statess) macro_f_memory_structures_clear(statess)
- #define macro_f_statess_t_resize(status, statess, length) status = f_type_statess_resize(length, &statess);
- #define macro_f_statess_t_adjust(status, statess, length) status = f_type_statess_adjust(length, &statess);
+ #define macro_f_statess_t_resize(status, statess, length) status = f_statess_resize(length, &statess);
+ #define macro_f_statess_t_adjust(status, statess, length) status = f_statess_adjust(length, &statess);
- #define macro_f_statess_t_delete_simple(statess) f_type_statess_resize(0, &statess);
- #define macro_f_statess_t_destroy_simple(statess) f_type_statess_adjust(0, &statess);
+ #define macro_f_statess_t_delete_simple(statess) f_statess_resize(0, &statess);
+ #define macro_f_statess_t_destroy_simple(statess) f_statess_adjust(0, &statess);
- #define macro_f_statess_t_increase(status, step, statess) status = f_type_statess_increase(step, &statess);
- #define macro_f_statess_t_increase_by(status, statess, amount) status = f_type_statess_increase_by(amount, &statess);
- #define macro_f_statess_t_decrease_by(status, statess, amount) status = f_type_statess_decrease_by(amount, &statess);
- #define macro_f_statess_t_decimate_by(status, statess, amount) status = f_type_statess_decimate_by(amount, &statess);
+ #define macro_f_statess_t_increase(status, step, statess) status = f_statess_increase(step, &statess);
+ #define macro_f_statess_t_increase_by(status, statess, amount) status = f_statess_increase_by(amount, &statess);
+ #define macro_f_statess_t_decrease_by(status, statess, amount) status = f_statess_decrease_by(amount, &statess);
+ #define macro_f_statess_t_decimate_by(status, statess, amount) status = f_statess_decimate_by(amount, &statess);
#endif // _di_f_statess_t_
/**
#ifndef _di_f_cells_t_
#define macro_f_cells_t_clear(cells) macro_f_memory_structures_clear(cells)
- #define macro_f_cells_t_resize(status, cells, length) status = f_type_cells_resize(length, &cells);
- #define macro_f_cells_t_adjust(status, cells, length) status = f_type_cells_adjust(length, &cells);
+ #define macro_f_cells_t_resize(status, cells, length) status = f_cells_resize(length, &cells);
+ #define macro_f_cells_t_adjust(status, cells, length) status = f_cells_adjust(length, &cells);
- #define macro_f_cells_t_delete_simple(cells) f_type_cells_resize(0, &cells);
- #define macro_f_cells_t_destroy_simple(cells) f_type_cells_adjust(0, &cells);
+ #define macro_f_cells_t_delete_simple(cells) f_cells_resize(0, &cells);
+ #define macro_f_cells_t_destroy_simple(cells) f_cells_adjust(0, &cells);
- #define macro_f_cells_t_increase(status, step, cells) status = f_type_cells_increase(step, &cells);
- #define macro_f_cells_t_increase_by(status, cells, amount) status = f_type_cells_increase_by(amount, &cells);
- #define macro_f_cells_t_decrease_by(status, cells, amount) status = f_type_cells_decrease_by(amount, &cells);
- #define macro_f_cells_t_decimate_by(status, cells, amount) status = f_type_cells_decimate_by(amount, &cells);
+ #define macro_f_cells_t_increase(status, step, cells) status = f_cells_increase(step, &cells);
+ #define macro_f_cells_t_increase_by(status, cells, amount) status = f_cells_increase_by(amount, &cells);
+ #define macro_f_cells_t_decrease_by(status, cells, amount) status = f_cells_decrease_by(amount, &cells);
+ #define macro_f_cells_t_decimate_by(status, cells, amount) status = f_cells_decimate_by(amount, &cells);
#endif // _di_f_cells_t_
/**
#ifndef _di_f_cellss_t_
#define macro_f_cellss_t_clear(cellss) macro_f_memory_structures_clear(cellss)
- #define macro_f_cellss_t_resize(status, cellss, length) status = f_type_cellss_resize(length, &cellss);
- #define macro_f_cellss_t_adjust(status, cellss, length) status = f_type_cellss_adjust(length, &cellss);
+ #define macro_f_cellss_t_resize(status, cellss, length) status = f_cellss_resize(length, &cellss);
+ #define macro_f_cellss_t_adjust(status, cellss, length) status = f_cellss_adjust(length, &cellss);
- #define macro_f_cellss_t_delete_simple(cellss) f_type_cellss_resize(0, &cellss);
- #define macro_f_cellss_t_destroy_simple(cellss) f_type_cellss_adjust(0, &cellss);
+ #define macro_f_cellss_t_delete_simple(cellss) f_cellss_resize(0, &cellss);
+ #define macro_f_cellss_t_destroy_simple(cellss) f_cellss_adjust(0, &cellss);
- #define macro_f_cellss_t_increase(status, step, cellss) status = f_type_cellss_increase(step, &cellss);
- #define macro_f_cellss_t_increase_by(status, cellss, amount) status = f_type_cellss_increase_by(amount, &cellss);
- #define macro_f_cellss_t_decrease_by(status, cellss, amount) status = f_type_cellss_decrease_by(amount, &cellss);
- #define macro_f_cellss_t_decimate_by(status, cellss, amount) status = f_type_cellss_decimate_by(amount, &cellss);
+ #define macro_f_cellss_t_increase(status, step, cellss) status = f_cellss_increase(step, &cellss);
+ #define macro_f_cellss_t_increase_by(status, cellss, amount) status = f_cellss_increase_by(amount, &cellss);
+ #define macro_f_cellss_t_decrease_by(status, cellss, amount) status = f_cellss_decrease_by(amount, &cellss);
+ #define macro_f_cellss_t_decimate_by(status, cellss, amount) status = f_cellss_decimate_by(amount, &cellss);
#endif // _di_f_cellss_t_
/**
#ifndef _di_f_fll_ids_t_
#define macro_f_fll_ids_t_clear(fll_ids) macro_f_memory_structures_clear(fll_ids)
- #define macro_f_fll_ids_t_resize(status, fll_ids, length) status = f_type_fll_ids_resize(length, &fll_ids);
- #define macro_f_fll_ids_t_adjust(status, fll_ids, length) status = f_type_fll_ids_adjust(length, &fll_ids);
+ #define macro_f_fll_ids_t_resize(status, fll_ids, length) status = f_fll_ids_resize(length, &fll_ids);
+ #define macro_f_fll_ids_t_adjust(status, fll_ids, length) status = f_fll_ids_adjust(length, &fll_ids);
- #define macro_f_fll_ids_t_delete_simple(fll_ids) f_type_fll_ids_resize(0, &fll_ids);
- #define macro_f_fll_ids_t_destroy_simple(fll_ids) f_type_fll_ids_adjust(0, &fll_ids);
+ #define macro_f_fll_ids_t_delete_simple(fll_ids) f_fll_ids_resize(0, &fll_ids);
+ #define macro_f_fll_ids_t_destroy_simple(fll_ids) f_fll_ids_adjust(0, &fll_ids);
- #define macro_f_fll_ids_t_increase(status, step, fll_ids) status = f_type_fll_ids_increase(step, &fll_ids);
- #define macro_f_fll_ids_t_increase_by(status, fll_ids, amount) status = f_type_fll_ids_increase_by(amount, &fll_ids);
- #define macro_f_fll_ids_t_decrease_by(status, fll_ids, amount) status = f_type_fll_ids_decrease_by(amount, &fll_ids);
- #define macro_f_fll_ids_t_decimate_by(status, fll_ids, amount) status = f_type_fll_ids_decimate_by(amount, &fll_ids);
+ #define macro_f_fll_ids_t_increase(status, step, fll_ids) status = f_fll_ids_increase(step, &fll_ids);
+ #define macro_f_fll_ids_t_increase_by(status, fll_ids, amount) status = f_fll_ids_increase_by(amount, &fll_ids);
+ #define macro_f_fll_ids_t_decrease_by(status, fll_ids, amount) status = f_fll_ids_decrease_by(amount, &fll_ids);
+ #define macro_f_fll_ids_t_decimate_by(status, fll_ids, amount) status = f_fll_ids_decimate_by(amount, &fll_ids);
#endif // _di_f_fll_ids_t_
/**
#ifndef _di_f_fll_idss_t_
#define macro_f_fll_idss_t_clear(fll_idss) macro_f_memory_structures_clear(fll_idss)
- #define macro_f_fll_idss_t_resize(status, fll_idss, length) status = f_type_fll_idss_resize(length, &fll_idss);
- #define macro_f_fll_idss_t_adjust(status, fll_idss, length) status = f_type_fll_idss_adjust(length, &fll_idss);
+ #define macro_f_fll_idss_t_resize(status, fll_idss, length) status = f_fll_idss_resize(length, &fll_idss);
+ #define macro_f_fll_idss_t_adjust(status, fll_idss, length) status = f_fll_idss_adjust(length, &fll_idss);
- #define macro_f_fll_idss_t_delete_simple(fll_idss) f_type_fll_idss_resize(0, &fll_idss);
- #define macro_f_fll_idss_t_destroy_simple(fll_idss) f_type_fll_idss_adjust(0, &fll_idss);
+ #define macro_f_fll_idss_t_delete_simple(fll_idss) f_fll_idss_resize(0, &fll_idss);
+ #define macro_f_fll_idss_t_destroy_simple(fll_idss) f_fll_idss_adjust(0, &fll_idss);
- #define macro_f_fll_idss_t_increase(status, step, fll_idss) status = f_type_fll_idss_increase(step, &fll_idss);
- #define macro_f_fll_idss_t_increase_by(status, fll_idss, amount) status = f_type_fll_idss_increase_by(amount, &fll_idss);
- #define macro_f_fll_idss_t_decrease_by(status, fll_idss, amount) status = f_type_fll_idss_decrease_by(amount, &fll_idss);
- #define macro_f_fll_idss_t_decimate_by(status, fll_idss, amount) status = f_type_fll_idss_decimate_by(amount, &fll_idss);
+ #define macro_f_fll_idss_t_increase(status, step, fll_idss) status = f_fll_idss_increase(step, &fll_idss);
+ #define macro_f_fll_idss_t_increase_by(status, fll_idss, amount) status = f_fll_idss_increase_by(amount, &fll_idss);
+ #define macro_f_fll_idss_t_decrease_by(status, fll_idss, amount) status = f_fll_idss_decrease_by(amount, &fll_idss);
+ #define macro_f_fll_idss_t_decimate_by(status, fll_idss, amount) status = f_fll_idss_decimate_by(amount, &fll_idss);
#endif // _di_f_fll_idss_t_
/**
#ifndef _di_f_array_lengths_t_
#define macro_f_array_lengths_t_clear(lengths) macro_f_memory_structures_clear(lengths)
- #define macro_f_array_lengths_t_resize(status, lengths, length) status = f_type_array_lengths_resize(length, &lengths);
- #define macro_f_array_lengths_t_adjust(status, lengths, length) status = f_type_array_lengths_adjust(length, &lengths);
+ #define macro_f_array_lengths_t_resize(status, lengths, length) status = f_array_lengths_resize(length, &lengths);
+ #define macro_f_array_lengths_t_adjust(status, lengths, length) status = f_array_lengths_adjust(length, &lengths);
- #define macro_f_array_lengths_t_delete_simple(lengths) f_type_array_lengths_resize(0, &lengths);
- #define macro_f_array_lengths_t_destroy_simple(lengths) f_type_array_lengths_adjust(0, &lengths);
+ #define macro_f_array_lengths_t_delete_simple(lengths) f_array_lengths_resize(0, &lengths);
+ #define macro_f_array_lengths_t_destroy_simple(lengths) f_array_lengths_adjust(0, &lengths);
- #define macro_f_array_lengths_t_increase(status, step, lengths) status = f_type_array_lengths_increase(step, &lengths);
- #define macro_f_array_lengths_t_increase_by(status, lengths, amount) status = f_type_array_lengths_increase_by(amount, &lengths);
- #define macro_f_array_lengths_t_decrease_by(status, lengths, amount) status = f_type_array_lengths_decrease_by(amount, &lengths);
- #define macro_f_array_lengths_t_decimate_by(status, lengths, amount) status = f_type_array_lengths_decimate_by(amount, &lengths);
+ #define macro_f_array_lengths_t_increase(status, step, lengths) status = f_array_lengths_increase(step, &lengths);
+ #define macro_f_array_lengths_t_increase_by(status, lengths, amount) status = f_array_lengths_increase_by(amount, &lengths);
+ #define macro_f_array_lengths_t_decrease_by(status, lengths, amount) status = f_array_lengths_decrease_by(amount, &lengths);
+ #define macro_f_array_lengths_t_decimate_by(status, lengths, amount) status = f_array_lengths_decimate_by(amount, &lengths);
#endif // _di_f_array_lengths_t_
/**
#ifndef _di_f_array_lengthss_t_
#define macro_f_array_lengthss_t_clear(lengthss) macro_f_memory_structures_clear(lengthss)
- #define macro_f_array_lengthss_t_resize(status, lengths, length) status = f_type_array_lengthss_resize(length, &lengths);
- #define macro_f_array_lengthss_t_adjust(status, lengths, length) status = f_type_array_lengthss_adjust(length, &lengths);
+ #define macro_f_array_lengthss_t_resize(status, lengths, length) status = f_array_lengthss_resize(length, &lengths);
+ #define macro_f_array_lengthss_t_adjust(status, lengths, length) status = f_array_lengthss_adjust(length, &lengths);
- #define macro_f_array_lengthss_t_delete_simple(lengths) f_type_array_lengthss_resize(0, &lengths);
- #define macro_f_array_lengthss_t_destroy_simple(lengths) f_type_array_lengthss_adjust(0, &lengths);
+ #define macro_f_array_lengthss_t_delete_simple(lengths) f_array_lengthss_resize(0, &lengths);
+ #define macro_f_array_lengthss_t_destroy_simple(lengths) f_array_lengthss_adjust(0, &lengths);
- #define macro_f_array_lengthss_t_increase(status, step, lengths) status = f_type_array_lengthss_increase(step, &lengths);
- #define macro_f_array_lengthss_t_increase_by(status, lengths, amount) status = f_type_array_lengthss_increase_by(amount, &lengths);
- #define macro_f_array_lengthss_t_decrease_by(status, lengths, amount) status = f_type_array_lengthss_decrease_by(amount, &lengths);
- #define macro_f_array_lengthss_t_decimate_by(status, lengths, amount) status = f_type_array_lengthss_decimate_by(amount, &lengths);
+ #define macro_f_array_lengthss_t_increase(status, step, lengths) status = f_array_lengthss_increase(step, &lengths);
+ #define macro_f_array_lengthss_t_increase_by(status, lengths, amount) status = f_array_lengthss_increase_by(amount, &lengths);
+ #define macro_f_array_lengthss_t_decrease_by(status, lengths, amount) status = f_array_lengthss_decrease_by(amount, &lengths);
+ #define macro_f_array_lengthss_t_decimate_by(status, lengths, amount) status = f_array_lengthss_decimate_by(amount, &lengths);
#endif // _di_f_array_lengthss_t_
/**
#ifndef _di_f_int8_t_
#define macro_f_int8s_t_clear(int8s) macro_f_memory_structures_clear(int8s)
- #define macro_f_int8s_t_resize(status, int8s, length) status = f_type_int8s_resize(length, &int8s);
- #define macro_f_int8s_t_adjust(status, int8s, length) status = f_type_int8s_adjust(length, &int8s);
+ #define macro_f_int8s_t_resize(status, int8s, length) status = f_int8s_resize(length, &int8s);
+ #define macro_f_int8s_t_adjust(status, int8s, length) status = f_int8s_adjust(length, &int8s);
- #define macro_f_int8s_t_increase(status, step, int8s) status = f_type_int8s_increase(step, &int8s);
- #define macro_f_int8s_t_increase_by(status, int8s, amount) status = f_type_int8s_increase_by(amount, &int8s);
- #define macro_f_int8s_t_decrease_by(status, int8s, amount) status = f_type_int8s_decrease_by(amount, &int8s);
- #define macro_f_int8s_t_decimate_by(status, int8s, amount) status = f_type_int8s_decimate_by(amount, &int8s);
+ #define macro_f_int8s_t_increase(status, step, int8s) status = f_int8s_increase(step, &int8s);
+ #define macro_f_int8s_t_increase_by(status, int8s, amount) status = f_int8s_increase_by(amount, &int8s);
+ #define macro_f_int8s_t_decrease_by(status, int8s, amount) status = f_int8s_decrease_by(amount, &int8s);
+ #define macro_f_int8s_t_decimate_by(status, int8s, amount) status = f_int8s_decimate_by(amount, &int8s);
- #define macro_f_int8s_t_delete_simple(int8s) f_type_int8s_resize(0, &int8s);
- #define macro_f_int8s_t_destroy_simple(int8s) f_type_int8s_adjust(0, &int8s);
+ #define macro_f_int8s_t_delete_simple(int8s) f_int8s_resize(0, &int8s);
+ #define macro_f_int8s_t_destroy_simple(int8s) f_int8s_adjust(0, &int8s);
#endif // _di_f_int8_t_
/**
#ifndef _di_f_int8ss_t_
#define macro_f_int8ss_t_clear(int8ss) macro_f_memory_structures_clear(int8ss)
- #define macro_f_int8ss_t_resize(status, int8ss, length) status = f_type_int8ss_resize(length, &int8ss);
- #define macro_f_int8ss_t_adjust(status, int8ss, length) status = f_type_int8ss_adjust(length, &int8ss);
+ #define macro_f_int8ss_t_resize(status, int8ss, length) status = f_int8ss_resize(length, &int8ss);
+ #define macro_f_int8ss_t_adjust(status, int8ss, length) status = f_int8ss_adjust(length, &int8ss);
- #define macro_f_int8ss_t_increase(status, step, int8ss) status = f_type_int8ss_increase(step, &int8ss);
- #define macro_f_int8ss_t_increase_by(status, int8ss, amount) status = f_type_int8ss_increase_by(amount, &int8ss);
- #define macro_f_int8ss_t_decrease_by(status, int8ss, amount) status = f_type_int8ss_decrease_by(amount, &int8ss);
- #define macro_f_int8ss_t_decimate_by(status, int8ss, amount) status = f_type_int8ss_decimate_by(amount, &int8ss);
+ #define macro_f_int8ss_t_increase(status, step, int8ss) status = f_int8ss_increase(step, &int8ss);
+ #define macro_f_int8ss_t_increase_by(status, int8ss, amount) status = f_int8ss_increase_by(amount, &int8ss);
+ #define macro_f_int8ss_t_decrease_by(status, int8ss, amount) status = f_int8ss_decrease_by(amount, &int8ss);
+ #define macro_f_int8ss_t_decimate_by(status, int8ss, amount) status = f_int8ss_decimate_by(amount, &int8ss);
- #define macro_f_int8ss_t_delete_simple(int8ss) f_type_int8ss_resize(0, &int8ss);
- #define macro_f_int8ss_t_destroy_simple(int8ss) f_type_int8ss_adjust(0, &int8ss);
+ #define macro_f_int8ss_t_delete_simple(int8ss) f_int8ss_resize(0, &int8ss);
+ #define macro_f_int8ss_t_destroy_simple(int8ss) f_int8ss_adjust(0, &int8ss);
#endif // _di_f_int8ss_t_
/**
#ifndef _di_f_uint8s_t_
#define macro_f_uint8s_t_clear(uint8s) macro_f_memory_structures_clear(uint8s)
- #define macro_f_uint8s_t_resize(status, uint8s, length) status = f_type_uint8s_resize(length, &uint8s);
- #define macro_f_uint8s_t_adjust(status, uint8s, length) status = f_type_uint8s_adjust(length, &uint8s);
+ #define macro_f_uint8s_t_resize(status, uint8s, length) status = f_uint8s_resize(length, &uint8s);
+ #define macro_f_uint8s_t_adjust(status, uint8s, length) status = f_uint8s_adjust(length, &uint8s);
- #define macro_f_uint8s_t_delete_simple(uint8s) f_type_uint8s_resize(0, &uint8s);
- #define macro_f_uint8s_t_destroy_simple(uint8s) f_type_uint8s_adjust(0, &uint8s);
+ #define macro_f_uint8s_t_delete_simple(uint8s) f_uint8s_resize(0, &uint8s);
+ #define macro_f_uint8s_t_destroy_simple(uint8s) f_uint8s_adjust(0, &uint8s);
- #define macro_f_uint8s_t_increase(status, step, uint8s) status = f_type_uint8s_increase(step, &uint8s);
- #define macro_f_uint8s_t_increase_by(status, uint8s, amount) status = f_type_uint8s_increase_by(amount, &uint8s);
- #define macro_f_uint8s_t_decrease_by(status, uint8s, amount) status = f_type_uint8s_decrease_by(amount, &uint8s);
- #define macro_f_uint8s_t_decimate_by(status, uint8s, amount) status = f_type_uint8s_decimate_by(amount, &uint8s);
+ #define macro_f_uint8s_t_increase(status, step, uint8s) status = f_uint8s_increase(step, &uint8s);
+ #define macro_f_uint8s_t_increase_by(status, uint8s, amount) status = f_uint8s_increase_by(amount, &uint8s);
+ #define macro_f_uint8s_t_decrease_by(status, uint8s, amount) status = f_uint8s_decrease_by(amount, &uint8s);
+ #define macro_f_uint8s_t_decimate_by(status, uint8s, amount) status = f_uint8s_decimate_by(amount, &uint8s);
#endif // _di_f_uint8s_t_
/**
#ifndef _di_f_uint8ss_t_
#define macro_f_uint8ss_t_clear(uint8ss) macro_f_memory_structures_clear(uint8ss)
- #define macro_f_uint8ss_t_resize(status, uint8ss, length) status = f_type_uint8ss_resize(length, &uint8ss);
- #define macro_f_uint8ss_t_adjust(status, uint8ss, length) status = f_type_uint8ss_adjust(length, &uint8ss);
+ #define macro_f_uint8ss_t_resize(status, uint8ss, length) status = f_uint8ss_resize(length, &uint8ss);
+ #define macro_f_uint8ss_t_adjust(status, uint8ss, length) status = f_uint8ss_adjust(length, &uint8ss);
- #define macro_f_uint8ss_t_delete_simple(uint8ss) f_type_uint8ss_resize(0, &uint8ss);
- #define macro_f_uint8ss_t_destroy_simple(uint8ss) f_type_uint8ss_adjust(0, &uint8ss);
+ #define macro_f_uint8ss_t_delete_simple(uint8ss) f_uint8ss_resize(0, &uint8ss);
+ #define macro_f_uint8ss_t_destroy_simple(uint8ss) f_uint8ss_adjust(0, &uint8ss);
- #define macro_f_uint8ss_t_increase(status, step, uint8ss) status = f_type_uint8ss_increase(step, &uint8ss);
- #define macro_f_uint8ss_t_increase_by(status, uint8ss, amount) status = f_type_uint8ss_increase_by(amount, &uint8ss);
- #define macro_f_uint8ss_t_decrease_by(status, uint8ss, amount) status = f_type_uint8ss_decrease_by(amount, &uint8ss);
- #define macro_f_uint8ss_t_decimate_by(status, uint8ss, amount) status = f_type_uint8ss_decimate_by(amount, &uint8ss);
+ #define macro_f_uint8ss_t_increase(status, step, uint8ss) status = f_uint8ss_increase(step, &uint8ss);
+ #define macro_f_uint8ss_t_increase_by(status, uint8ss, amount) status = f_uint8ss_increase_by(amount, &uint8ss);
+ #define macro_f_uint8ss_t_decrease_by(status, uint8ss, amount) status = f_uint8ss_decrease_by(amount, &uint8ss);
+ #define macro_f_uint8ss_t_decimate_by(status, uint8ss, amount) status = f_uint8ss_decimate_by(amount, &uint8ss);
#endif // _di_f_uint8ss_t_
/**
#ifndef _di_f_int16s_t_
#define macro_f_int16s_t_clear(int16s) macro_f_memory_structures_clear(int16s)
- #define macro_f_int16s_t_resize(status, int16s, length) status = f_type_int16s_resize(length, &int16s);
- #define macro_f_int16s_t_adjust(status, int16s, length) status = f_type_int16s_adjust(length, &int16s);
+ #define macro_f_int16s_t_resize(status, int16s, length) status = f_int16s_resize(length, &int16s);
+ #define macro_f_int16s_t_adjust(status, int16s, length) status = f_int16s_adjust(length, &int16s);
- #define macro_f_int16s_t_increase(status, step, int16s) status = f_type_int16s_increase(step, &int16s);
- #define macro_f_int16s_t_increase_by(status, int16s, amount) status = f_type_int16s_increase_by(amount, &int16s);
- #define macro_f_int16s_t_decrease_by(status, int16s, amount) status = f_type_int16s_decrease_by(amount, &int16s);
- #define macro_f_int16s_t_decimate_by(status, int16s, amount) status = f_type_int16s_decimate_by(amount, &int16s);
+ #define macro_f_int16s_t_increase(status, step, int16s) status = f_int16s_increase(step, &int16s);
+ #define macro_f_int16s_t_increase_by(status, int16s, amount) status = f_int16s_increase_by(amount, &int16s);
+ #define macro_f_int16s_t_decrease_by(status, int16s, amount) status = f_int16s_decrease_by(amount, &int16s);
+ #define macro_f_int16s_t_decimate_by(status, int16s, amount) status = f_int16s_decimate_by(amount, &int16s);
- #define macro_f_int16s_t_delete_simple(int16s) f_type_int16s_resize(0, &int16s);
- #define macro_f_int16s_t_destroy_simple(int16s) f_type_int16s_adjust(0, &int16s);
+ #define macro_f_int16s_t_delete_simple(int16s) f_int16s_resize(0, &int16s);
+ #define macro_f_int16s_t_destroy_simple(int16s) f_int16s_adjust(0, &int16s);
#endif // _di_f_int16s_t_
/**
#ifndef _di_f_int16ss_t_
#define macro_f_int16ss_t_clear(int16ss) macro_f_memory_structures_clear(int16ss)
- #define macro_f_int16ss_t_resize(status, int16ss, length) status = f_type_int16ss_resize(length, &int16ss);
- #define macro_f_int16ss_t_adjust(status, int16ss, length) status = f_type_int16ss_adjust(length, &int16ss);
+ #define macro_f_int16ss_t_resize(status, int16ss, length) status = f_int16ss_resize(length, &int16ss);
+ #define macro_f_int16ss_t_adjust(status, int16ss, length) status = f_int16ss_adjust(length, &int16ss);
- #define macro_f_int16ss_t_increase(status, step, int16ss) status = f_type_int16ss_increase(step, &int16ss);
- #define macro_f_int16ss_t_increase_by(status, int16ss, amount) status = f_type_int16ss_increase_by(amount, &int16ss);
- #define macro_f_int16ss_t_decrease_by(status, int16ss, amount) status = f_type_int16ss_decrease_by(amount, &int16ss);
- #define macro_f_int16ss_t_decimate_by(status, int16ss, amount) status = f_type_int16ss_decimate_by(amount, &int16ss);
+ #define macro_f_int16ss_t_increase(status, step, int16ss) status = f_int16ss_increase(step, &int16ss);
+ #define macro_f_int16ss_t_increase_by(status, int16ss, amount) status = f_int16ss_increase_by(amount, &int16ss);
+ #define macro_f_int16ss_t_decrease_by(status, int16ss, amount) status = f_int16ss_decrease_by(amount, &int16ss);
+ #define macro_f_int16ss_t_decimate_by(status, int16ss, amount) status = f_int16ss_decimate_by(amount, &int16ss);
- #define macro_f_int16ss_t_delete_simple(int16ss) f_type_int16ss_resize(0, &int16ss);
- #define macro_f_int16ss_t_destroy_simple(int16ss) f_type_int16ss_adjust(0, &int16ss);
+ #define macro_f_int16ss_t_delete_simple(int16ss) f_int16ss_resize(0, &int16ss);
+ #define macro_f_int16ss_t_destroy_simple(int16ss) f_int16ss_adjust(0, &int16ss);
#endif // _di_f_int16ss_t_
/**
#ifndef _di_f_uint16s_t_
#define macro_f_uint16s_t_clear(uint16s) macro_f_memory_structures_clear(uint16s)
- #define macro_f_uint16s_t_resize(status, uint16s, length) status = f_type_uint16s_resize(length, &uint16s);
- #define macro_f_uint16s_t_adjust(status, uint16s, length) status = f_type_uint16s_adjust(length, &uint16s);
+ #define macro_f_uint16s_t_resize(status, uint16s, length) status = f_uint16s_resize(length, &uint16s);
+ #define macro_f_uint16s_t_adjust(status, uint16s, length) status = f_uint16s_adjust(length, &uint16s);
- #define macro_f_uint16s_t_delete_simple(uint16s) f_type_uint16s_resize(0, &uint16s);
- #define macro_f_uint16s_t_destroy_simple(uint16s) f_type_uint16s_adjust(0, &uint16s);
+ #define macro_f_uint16s_t_delete_simple(uint16s) f_uint16s_resize(0, &uint16s);
+ #define macro_f_uint16s_t_destroy_simple(uint16s) f_uint16s_adjust(0, &uint16s);
- #define macro_f_uint16s_t_increase(status, step, uint16s) status = f_type_uint16s_increase(step, &uint16s);
- #define macro_f_uint16s_t_increase_by(status, uint16s, amount) status = f_type_uint16s_increase_by(amount, &uint16s);
- #define macro_f_uint16s_t_decrease_by(status, uint16s, amount) status = f_type_uint16s_decrease_by(amount, &uint16s);
- #define macro_f_uint16s_t_decimate_by(status, uint16s, amount) status = f_type_uint16s_decimate_by(amount, &uint16s);
+ #define macro_f_uint16s_t_increase(status, step, uint16s) status = f_uint16s_increase(step, &uint16s);
+ #define macro_f_uint16s_t_increase_by(status, uint16s, amount) status = f_uint16s_increase_by(amount, &uint16s);
+ #define macro_f_uint16s_t_decrease_by(status, uint16s, amount) status = f_uint16s_decrease_by(amount, &uint16s);
+ #define macro_f_uint16s_t_decimate_by(status, uint16s, amount) status = f_uint16s_decimate_by(amount, &uint16s);
#endif // _di_f_uint16s_t_
/**
#ifndef _di_f_uint16ss_t_
#define macro_f_uint16ss_t_clear(uint16ss) macro_f_memory_structures_clear(uint16ss)
- #define macro_f_uint16ss_t_resize(status, uint16ss, length) status = f_type_uint16ss_resize(length, &uint16ss);
- #define macro_f_uint16ss_t_adjust(status, uint16ss, length) status = f_type_uint16ss_adjust(length, &uint16ss);
+ #define macro_f_uint16ss_t_resize(status, uint16ss, length) status = f_uint16ss_resize(length, &uint16ss);
+ #define macro_f_uint16ss_t_adjust(status, uint16ss, length) status = f_uint16ss_adjust(length, &uint16ss);
- #define macro_f_uint16ss_t_delete_simple(uint16ss) f_type_uint16ss_resize(0, &uint16ss);
- #define macro_f_uint16ss_t_destroy_simple(uint16ss) f_type_uint16ss_adjust(0, &uint16ss);
+ #define macro_f_uint16ss_t_delete_simple(uint16ss) f_uint16ss_resize(0, &uint16ss);
+ #define macro_f_uint16ss_t_destroy_simple(uint16ss) f_uint16ss_adjust(0, &uint16ss);
- #define macro_f_uint16ss_t_increase(status, step, uint16ss) status = f_type_uint16ss_increase(step, &uint16ss);
- #define macro_f_uint16ss_t_increase_by(status, uint16ss, amount) status = f_type_uint16ss_increase_by(amount, &uint16ss);
- #define macro_f_uint16ss_t_decrease_by(status, uint16ss, amount) status = f_type_uint16ss_decrease_by(amount, &uint16ss);
- #define macro_f_uint16ss_t_decimate_by(status, uint16ss, amount) status = f_type_uint16ss_decimate_by(amount, &uint16ss);
+ #define macro_f_uint16ss_t_increase(status, step, uint16ss) status = f_uint16ss_increase(step, &uint16ss);
+ #define macro_f_uint16ss_t_increase_by(status, uint16ss, amount) status = f_uint16ss_increase_by(amount, &uint16ss);
+ #define macro_f_uint16ss_t_decrease_by(status, uint16ss, amount) status = f_uint16ss_decrease_by(amount, &uint16ss);
+ #define macro_f_uint16ss_t_decimate_by(status, uint16ss, amount) status = f_uint16ss_decimate_by(amount, &uint16ss);
#endif // _di_f_uint16ss_t_
/**
#ifndef _di_f_int32s_t_
#define macro_f_int32s_t_clear(int32s) macro_f_memory_structures_clear(int32s)
- #define macro_f_int32s_t_resize(status, int32s, length) status = f_type_int32s_resize(length, &int32s);
- #define macro_f_int32s_t_adjust(status, int32s, length) status = f_type_int32s_adjust(length, &int32s);
+ #define macro_f_int32s_t_resize(status, int32s, length) status = f_int32s_resize(length, &int32s);
+ #define macro_f_int32s_t_adjust(status, int32s, length) status = f_int32s_adjust(length, &int32s);
- #define macro_f_int32s_t_delete_simple(int32s) f_type_int32s_resize(0, &int32s);
- #define macro_f_int32s_t_destroy_simple(int32s) f_type_int32s_adjust(0, &int32s);
+ #define macro_f_int32s_t_delete_simple(int32s) f_int32s_resize(0, &int32s);
+ #define macro_f_int32s_t_destroy_simple(int32s) f_int32s_adjust(0, &int32s);
- #define macro_f_int32s_t_increase(status, step, int32s) status = f_type_int32s_increase(step, &int32s);
- #define macro_f_int32s_t_increase_by(status, int32s, amount) status = f_type_int32s_increase_by(amount, &int32s);
- #define macro_f_int32s_t_decrease_by(status, int32s, amount) status = f_type_int32s_decrease_by(amount, &int32s);
- #define macro_f_int32s_t_decimate_by(status, int32s, amount) status = f_type_int32s_decimate_by(amount, &int32s);
+ #define macro_f_int32s_t_increase(status, step, int32s) status = f_int32s_increase(step, &int32s);
+ #define macro_f_int32s_t_increase_by(status, int32s, amount) status = f_int32s_increase_by(amount, &int32s);
+ #define macro_f_int32s_t_decrease_by(status, int32s, amount) status = f_int32s_decrease_by(amount, &int32s);
+ #define macro_f_int32s_t_decimate_by(status, int32s, amount) status = f_int32s_decimate_by(amount, &int32s);
#endif // _di_f_int32s_t_
/**
#ifndef _di_f_int32ss_t_
#define macro_f_int32ss_t_clear(int32ss) macro_f_memory_structures_clear(int32ss)
- #define macro_f_int32ss_t_resize(status, int32ss, length) status = f_type_int32ss_resize(length, &int32ss);
- #define macro_f_int32ss_t_adjust(status, int32ss, length) status = f_type_int32ss_adjust(length, &int32ss);
+ #define macro_f_int32ss_t_resize(status, int32ss, length) status = f_int32ss_resize(length, &int32ss);
+ #define macro_f_int32ss_t_adjust(status, int32ss, length) status = f_int32ss_adjust(length, &int32ss);
- #define macro_f_int32ss_t_delete_simple(int32ss) f_type_int32ss_resize(0, &int32ss);
- #define macro_f_int32ss_t_destroy_simple(int32ss) f_type_int32ss_adjust(0, &int32ss);
+ #define macro_f_int32ss_t_delete_simple(int32ss) f_int32ss_resize(0, &int32ss);
+ #define macro_f_int32ss_t_destroy_simple(int32ss) f_int32ss_adjust(0, &int32ss);
- #define macro_f_int32ss_t_increase(status, step, int32ss) status = f_type_int32ss_increase(step, &int32ss);
- #define macro_f_int32ss_t_increase_by(status, int32ss, amount) status = f_type_int32ss_increase_by(amount, &int32ss);
- #define macro_f_int32ss_t_decrease_by(status, int32ss, amount) status = f_type_int32ss_decrease_by(amount, &int32ss);
- #define macro_f_int32ss_t_decimate_by(status, int32ss, amount) status = f_type_int32ss_decimate_by(amount, &int32ss);
+ #define macro_f_int32ss_t_increase(status, step, int32ss) status = f_int32ss_increase(step, &int32ss);
+ #define macro_f_int32ss_t_increase_by(status, int32ss, amount) status = f_int32ss_increase_by(amount, &int32ss);
+ #define macro_f_int32ss_t_decrease_by(status, int32ss, amount) status = f_int32ss_decrease_by(amount, &int32ss);
+ #define macro_f_int32ss_t_decimate_by(status, int32ss, amount) status = f_int32ss_decimate_by(amount, &int32ss);
#endif // _di_f_int32ss_t_
/**
#ifndef _di_f_uint32s_t_
#define macro_f_uint32s_t_clear(uint32s) macro_f_memory_structures_clear(uint32s)
- #define macro_f_uint32s_t_resize(status, uint32s, length) status = f_type_uint32s_resize(length, &uint32s);
- #define macro_f_uint32s_t_adjust(status, uint32s, length) status = f_type_uint32s_adjust(length, &uint32s);
+ #define macro_f_uint32s_t_resize(status, uint32s, length) status = f_uint32s_resize(length, &uint32s);
+ #define macro_f_uint32s_t_adjust(status, uint32s, length) status = f_uint32s_adjust(length, &uint32s);
- #define macro_f_uint32s_t_delete_simple(uint32s) f_type_uint32s_resize(0, &uint32s);
- #define macro_f_uint32s_t_destroy_simple(uint32s) f_type_uint32s_adjust(0, &uint32s);
+ #define macro_f_uint32s_t_delete_simple(uint32s) f_uint32s_resize(0, &uint32s);
+ #define macro_f_uint32s_t_destroy_simple(uint32s) f_uint32s_adjust(0, &uint32s);
- #define macro_f_uint32s_t_increase(status, step, uint32s) status = f_type_uint32s_increase(step, &uint32s);
- #define macro_f_uint32s_t_increase_by(status, uint32s, amount) status = f_type_uint32s_increase_by(amount, &uint32s);
- #define macro_f_uint32s_t_decrease_by(status, uint32s, amount) status = f_type_uint32s_decrease_by(amount, &uint32s);
- #define macro_f_uint32s_t_decimate_by(status, uint32s, amount) status = f_type_uint32s_decimate_by(amount, &uint32s);
+ #define macro_f_uint32s_t_increase(status, step, uint32s) status = f_uint32s_increase(step, &uint32s);
+ #define macro_f_uint32s_t_increase_by(status, uint32s, amount) status = f_uint32s_increase_by(amount, &uint32s);
+ #define macro_f_uint32s_t_decrease_by(status, uint32s, amount) status = f_uint32s_decrease_by(amount, &uint32s);
+ #define macro_f_uint32s_t_decimate_by(status, uint32s, amount) status = f_uint32s_decimate_by(amount, &uint32s);
#endif // _di_f_uint32s_t_
/**
#ifndef _di_f_uint32ss_t_
#define macro_f_uint32ss_t_clear(uint32ss) macro_f_memory_structures_clear(uint32ss)
- #define macro_f_uint32ss_t_resize(status, uint32ss, length) status = f_type_uint32ss_resize(length, &uint32ss);
- #define macro_f_uint32ss_t_adjust(status, uint32ss, length) status = f_type_uint32ss_adjust(length, &uint32ss);
+ #define macro_f_uint32ss_t_resize(status, uint32ss, length) status = f_uint32ss_resize(length, &uint32ss);
+ #define macro_f_uint32ss_t_adjust(status, uint32ss, length) status = f_uint32ss_adjust(length, &uint32ss);
- #define macro_f_uint32ss_t_delete_simple(uint32ss) f_type_uint32ss_resize(0, &uint32ss);
- #define macro_f_uint32ss_t_destroy_simple(uint32ss) f_type_uint32ss_adjust(0, &uint32ss);
+ #define macro_f_uint32ss_t_delete_simple(uint32ss) f_uint32ss_resize(0, &uint32ss);
+ #define macro_f_uint32ss_t_destroy_simple(uint32ss) f_uint32ss_adjust(0, &uint32ss);
- #define macro_f_uint32ss_t_increase(status, step, uint32ss) status = f_type_uint32ss_increase(step, &uint32ss);
- #define macro_f_uint32ss_t_increase_by(status, uint32ss, amount) status = f_type_uint32ss_increase_by(amount, &uint32ss);
- #define macro_f_uint32ss_t_decrease_by(status, uint32ss, amount) status = f_type_uint32ss_decrease_by(amount, &uint32ss);
- #define macro_f_uint32ss_t_decimate_by(status, uint32ss, amount) status = f_type_uint32ss_decimate_by(amount, &uint32ss);
+ #define macro_f_uint32ss_t_increase(status, step, uint32ss) status = f_uint32ss_increase(step, &uint32ss);
+ #define macro_f_uint32ss_t_increase_by(status, uint32ss, amount) status = f_uint32ss_increase_by(amount, &uint32ss);
+ #define macro_f_uint32ss_t_decrease_by(status, uint32ss, amount) status = f_uint32ss_decrease_by(amount, &uint32ss);
+ #define macro_f_uint32ss_t_decimate_by(status, uint32ss, amount) status = f_uint32ss_decimate_by(amount, &uint32ss);
#endif // _di_f_uint32ss_t_
/**
#ifndef _di_f_int64s_t_
#define macro_f_int64s_t_clear(int64s) macro_f_memory_structures_clear(int64s)
- #define macro_f_int64s_t_resize(status, int64s, length) status = f_type_int64s_resize(length, &int64s);
- #define macro_f_int64s_t_adjust(status, int64s, length) status = f_type_int64s_adjust(length, &int64s);
+ #define macro_f_int64s_t_resize(status, int64s, length) status = f_int64s_resize(length, &int64s);
+ #define macro_f_int64s_t_adjust(status, int64s, length) status = f_int64s_adjust(length, &int64s);
- #define macro_f_int64s_t_increase(status, step, int64s) status = f_type_int64s_increase(step, &int64s);
- #define macro_f_int64s_t_increase_by(status, int64s, amount) status = f_type_int64s_increase_by(amount, &int64s);
- #define macro_f_int64s_t_decrease_by(status, int64s, amount) status = f_type_int64s_decrease_by(amount, &int64s);
- #define macro_f_int64s_t_decimate_by(status, int64s, amount) status = f_type_int64s_decimate_by(amount, &int64s);
+ #define macro_f_int64s_t_increase(status, step, int64s) status = f_int64s_increase(step, &int64s);
+ #define macro_f_int64s_t_increase_by(status, int64s, amount) status = f_int64s_increase_by(amount, &int64s);
+ #define macro_f_int64s_t_decrease_by(status, int64s, amount) status = f_int64s_decrease_by(amount, &int64s);
+ #define macro_f_int64s_t_decimate_by(status, int64s, amount) status = f_int64s_decimate_by(amount, &int64s);
- #define macro_f_int64s_t_delete_simple(int64s) f_type_int64s_resize(0, &int64s);
- #define macro_f_int64s_t_destroy_simple(int64s) f_type_int64s_adjust(0, &int64s);
+ #define macro_f_int64s_t_delete_simple(int64s) f_int64s_resize(0, &int64s);
+ #define macro_f_int64s_t_destroy_simple(int64s) f_int64s_adjust(0, &int64s);
#endif // _di_f_int64s_t_
/**
#ifndef _di_f_int64ss_t_
#define macro_f_int64ss_t_clear(int64ss) macro_f_memory_structures_clear(int64ss)
- #define macro_f_int64ss_t_resize(status, int64ss, length) status = f_type_int64ss_resize(length, &int64ss);
- #define macro_f_int64ss_t_adjust(status, int64ss, length) status = f_type_int64ss_adjust(length, &int64ss);
+ #define macro_f_int64ss_t_resize(status, int64ss, length) status = f_int64ss_resize(length, &int64ss);
+ #define macro_f_int64ss_t_adjust(status, int64ss, length) status = f_int64ss_adjust(length, &int64ss);
- #define macro_f_int64ss_t_increase(status, step, int64ss) status = f_type_int64ss_increase(step, &int64ss);
- #define macro_f_int64ss_t_increase_by(status, int64ss, amount) status = f_type_int64ss_increase_by(amount, &int64ss);
- #define macro_f_int64ss_t_decrease_by(status, int64ss, amount) status = f_type_int64ss_decrease_by(amount, &int64ss);
- #define macro_f_int64ss_t_decimate_by(status, int64ss, amount) status = f_type_int64ss_decimate_by(amount, &int64ss);
+ #define macro_f_int64ss_t_increase(status, step, int64ss) status = f_int64ss_increase(step, &int64ss);
+ #define macro_f_int64ss_t_increase_by(status, int64ss, amount) status = f_int64ss_increase_by(amount, &int64ss);
+ #define macro_f_int64ss_t_decrease_by(status, int64ss, amount) status = f_int64ss_decrease_by(amount, &int64ss);
+ #define macro_f_int64ss_t_decimate_by(status, int64ss, amount) status = f_int64ss_decimate_by(amount, &int64ss);
- #define macro_f_int64ss_t_delete_simple(int64ss) f_type_int64ss_resize(0, &int64ss);
- #define macro_f_int64ss_t_destroy_simple(int64ss) f_type_int64ss_adjust(0, &int64ss);
+ #define macro_f_int64ss_t_delete_simple(int64ss) f_int64ss_resize(0, &int64ss);
+ #define macro_f_int64ss_t_destroy_simple(int64ss) f_int64ss_adjust(0, &int64ss);
#endif // _di_f_int64ss_t_
/**
#ifndef _di_f_uint64s_t_
#define macro_f_uint64s_t_clear(uint64s) macro_f_memory_structures_clear(uint64s)
- #define macro_f_uint64s_t_resize(status, uint64s, length) status = f_type_uint64s_resize(length, &uint64s);
- #define macro_f_uint64s_t_adjust(status, uint64s, length) status = f_type_uint64s_adjust(length, &uint64s);
+ #define macro_f_uint64s_t_resize(status, uint64s, length) status = f_uint64s_resize(length, &uint64s);
+ #define macro_f_uint64s_t_adjust(status, uint64s, length) status = f_uint64s_adjust(length, &uint64s);
- #define macro_f_uint64s_t_increase(status, step, uint64s) status = f_type_uint64s_increase(step, &uint64s);
- #define macro_f_uint64s_t_increase_by(status, uint64s, amount) status = f_type_uint64s_increase_by(amount, &uint64s);
- #define macro_f_uint64s_t_decrease_by(status, uint64s, amount) status = f_type_uint64s_decrease_by(amount, &uint64s);
- #define macro_f_uint64s_t_decimate_by(status, uint64s, amount) status = f_type_uint64s_decimate_by(amount, &uint64s);
+ #define macro_f_uint64s_t_increase(status, step, uint64s) status = f_uint64s_increase(step, &uint64s);
+ #define macro_f_uint64s_t_increase_by(status, uint64s, amount) status = f_uint64s_increase_by(amount, &uint64s);
+ #define macro_f_uint64s_t_decrease_by(status, uint64s, amount) status = f_uint64s_decrease_by(amount, &uint64s);
+ #define macro_f_uint64s_t_decimate_by(status, uint64s, amount) status = f_uint64s_decimate_by(amount, &uint64s);
- #define macro_f_uint64s_t_delete_simple(uint64s) f_type_uint64s_resize(0, &uint64s);
- #define macro_f_uint64s_t_destroy_simple(uint64s) f_type_uint64s_adjust(0, &uint64s);
+ #define macro_f_uint64s_t_delete_simple(uint64s) f_uint64s_resize(0, &uint64s);
+ #define macro_f_uint64s_t_destroy_simple(uint64s) f_uint64s_adjust(0, &uint64s);
#endif // _di_f_uint64s_t_
/**
#ifndef _di_f_uint64ss_t_
#define macro_f_uint64ss_t_clear(uint64ss) macro_f_memory_structures_clear(uint64ss)
- #define macro_f_uint64ss_t_resize(status, uint64ss, length) status = f_type_uint64ss_resize(length, &uint64ss);
- #define macro_f_uint64ss_t_adjust(status, uint64ss, length) status = f_type_uint64ss_adjust(length, &uint64ss);
+ #define macro_f_uint64ss_t_resize(status, uint64ss, length) status = f_uint64ss_resize(length, &uint64ss);
+ #define macro_f_uint64ss_t_adjust(status, uint64ss, length) status = f_uint64ss_adjust(length, &uint64ss);
- #define macro_f_uint64ss_t_increase(status, step, uint64ss) status = f_type_uint64ss_increase(step, &uint64ss);
- #define macro_f_uint64ss_t_increase_by(status, uint64ss, amount) status = f_type_uint64ss_increase_by(amount, &uint64ss);
- #define macro_f_uint64ss_t_decrease_by(status, uint64ss, amount) status = f_type_uint64ss_decrease_by(amount, &uint64ss);
- #define macro_f_uint64ss_t_decimate_by(status, uint64ss, amount) status = f_type_uint64ss_decimate_by(amount, &uint64ss);
+ #define macro_f_uint64ss_t_increase(status, step, uint64ss) status = f_uint64ss_increase(step, &uint64ss);
+ #define macro_f_uint64ss_t_increase_by(status, uint64ss, amount) status = f_uint64ss_increase_by(amount, &uint64ss);
+ #define macro_f_uint64ss_t_decrease_by(status, uint64ss, amount) status = f_uint64ss_decrease_by(amount, &uint64ss);
+ #define macro_f_uint64ss_t_decimate_by(status, uint64ss, amount) status = f_uint64ss_decimate_by(amount, &uint64ss);
- #define macro_f_uint64ss_t_delete_simple(uint64ss) f_type_uint64ss_resize(0, &uint64ss);
- #define macro_f_uint64ss_t_destroy_simple(uint64ss) f_type_uint64ss_adjust(0, &uint64ss);
+ #define macro_f_uint64ss_t_delete_simple(uint64ss) f_uint64ss_resize(0, &uint64ss);
+ #define macro_f_uint64ss_t_destroy_simple(uint64ss) f_uint64ss_adjust(0, &uint64ss);
#endif // _di_f_uint64ss_t_
/**
#ifndef _di_f_int128s_t_
#define macro_f_int128s_t_clear(int128s) macro_f_memory_structures_clear(int128s)
- #define macro_f_int128s_t_resize(status, int128s, length) status = f_type_int128s_resize(length, &int128s);
- #define macro_f_int128s_t_adjust(status, int128s, length) status = f_type_int128s_adjust(length, &int128s);
+ #define macro_f_int128s_t_resize(status, int128s, length) status = f_int128s_resize(length, &int128s);
+ #define macro_f_int128s_t_adjust(status, int128s, length) status = f_int128s_adjust(length, &int128s);
- #define macro_f_int128s_t_delete_simple(int128s) f_type_int128s_resize(0, &int128s);
- #define macro_f_int128s_t_destroy_simple(int128s) f_type_int128s_adjust(0, &int128s);
+ #define macro_f_int128s_t_delete_simple(int128s) f_int128s_resize(0, &int128s);
+ #define macro_f_int128s_t_destroy_simple(int128s) f_int128s_adjust(0, &int128s);
- #define macro_f_int128s_t_increase(status, step, int128s) status = f_type_int128s_increase(step, &int128s);
- #define macro_f_int128s_t_increase_by(status, int128s, amount) status = f_type_int128s_increase_by(amount, &int128s);
- #define macro_f_int128s_t_decrease_by(status, int128s, amount) status = f_type_int128s_decrease_by(amount, &int128s);
- #define macro_f_int128s_t_decimate_by(status, int128s, amount) status = f_type_int128s_decimate_by(amount, &int128s);
+ #define macro_f_int128s_t_increase(status, step, int128s) status = f_int128s_increase(step, &int128s);
+ #define macro_f_int128s_t_increase_by(status, int128s, amount) status = f_int128s_increase_by(amount, &int128s);
+ #define macro_f_int128s_t_decrease_by(status, int128s, amount) status = f_int128s_decrease_by(amount, &int128s);
+ #define macro_f_int128s_t_decimate_by(status, int128s, amount) status = f_int128s_decimate_by(amount, &int128s);
#endif // _di_f_int128s_t_
/**
#ifndef _di_f_int128ss_t_
#define macro_f_int128ss_t_clear(int128ss) macro_f_memory_structures_clear(int128ss)
- #define macro_f_int128ss_t_resize(status, int128ss, length) status = f_type_int128ss_resize(length, &int128ss);
- #define macro_f_int128ss_t_adjust(status, int128ss, length) status = f_type_int128ss_adjust(length, &int128ss);
+ #define macro_f_int128ss_t_resize(status, int128ss, length) status = f_int128ss_resize(length, &int128ss);
+ #define macro_f_int128ss_t_adjust(status, int128ss, length) status = f_int128ss_adjust(length, &int128ss);
- #define macro_f_int128ss_t_delete_simple(int128ss) f_type_int128ss_resize(0, &int128ss);
- #define macro_f_int128ss_t_destroy_simple(int128ss) f_type_int128ss_adjust(0, &int128ss);
+ #define macro_f_int128ss_t_delete_simple(int128ss) f_int128ss_resize(0, &int128ss);
+ #define macro_f_int128ss_t_destroy_simple(int128ss) f_int128ss_adjust(0, &int128ss);
- #define macro_f_int128ss_t_increase(status, step, int128ss) status = f_type_int128ss_increase(step, &int128ss);
- #define macro_f_int128ss_t_increase_by(status, int128ss, amount) status = f_type_int128ss_increase_by(amount, &int128ss);
- #define macro_f_int128ss_t_decrease_by(status, int128ss, amount) status = f_type_int128ss_decrease_by(amount, &int128ss);
- #define macro_f_int128ss_t_decimate_by(status, int128ss, amount) status = f_type_int128ss_decimate_by(amount, &int128ss);
+ #define macro_f_int128ss_t_increase(status, step, int128ss) status = f_int128ss_increase(step, &int128ss);
+ #define macro_f_int128ss_t_increase_by(status, int128ss, amount) status = f_int128ss_increase_by(amount, &int128ss);
+ #define macro_f_int128ss_t_decrease_by(status, int128ss, amount) status = f_int128ss_decrease_by(amount, &int128ss);
+ #define macro_f_int128ss_t_decimate_by(status, int128ss, amount) status = f_int128ss_decimate_by(amount, &int128ss);
#endif // _di_f_int128ss_t_
/**
#ifndef _di_f_uint128s_t_
#define macro_f_uint128s_t_clear(uint128s) macro_f_memory_structures_clear(uint128s)
- #define macro_f_uint128s_t_resize(status, uint128s, length) status = f_type_uint128s_resize(length, &uint128s);
- #define macro_f_uint128s_t_adjust(status, uint128s, length) status = f_type_uint128s_adjust(length, &uint128s);
+ #define macro_f_uint128s_t_resize(status, uint128s, length) status = f_uint128s_resize(length, &uint128s);
+ #define macro_f_uint128s_t_adjust(status, uint128s, length) status = f_uint128s_adjust(length, &uint128s);
- #define macro_f_uint128s_t_delete_simple(uint128s) f_type_uint128s_resize(0, &uint128s);
- #define macro_f_uint128s_t_destroy_simple(uint128s) f_type_uint128s_adjust(0, &uint128s);
+ #define macro_f_uint128s_t_delete_simple(uint128s) f_uint128s_resize(0, &uint128s);
+ #define macro_f_uint128s_t_destroy_simple(uint128s) f_uint128s_adjust(0, &uint128s);
- #define macro_f_uint128s_t_increase(status, step, uint128s) status = f_type_uint128s_increase(step, &uint128s);
- #define macro_f_uint128s_t_increase_by(status, uint128s, amount) status = f_type_uint128s_increase_by(amount, &uint128s);
- #define macro_f_uint128s_t_decrease_by(status, uint128s, amount) status = f_type_uint128s_decrease_by(amount, &uint128s);
- #define macro_f_uint128s_t_decimate_by(status, uint128s, amount) status = f_type_uint128s_decimate_by(amount, &uint128s);
+ #define macro_f_uint128s_t_increase(status, step, uint128s) status = f_uint128s_increase(step, &uint128s);
+ #define macro_f_uint128s_t_increase_by(status, uint128s, amount) status = f_uint128s_increase_by(amount, &uint128s);
+ #define macro_f_uint128s_t_decrease_by(status, uint128s, amount) status = f_uint128s_decrease_by(amount, &uint128s);
+ #define macro_f_uint128s_t_decimate_by(status, uint128s, amount) status = f_uint128s_decimate_by(amount, &uint128s);
#endif // _di_f_uint128s_t_
/**
#ifndef _di_f_uint128ss_t_
#define macro_f_uint128ss_t_clear(uint128ss) macro_f_memory_structures_clear(uint128ss)
- #define macro_f_uint128ss_t_resize(status, uint128ss, length) status = f_type_uint128ss_resize(length, &uint128ss);
- #define macro_f_uint128ss_t_adjust(status, uint128ss, length) status = f_type_uint128ss_adjust(length, &uint128ss);
+ #define macro_f_uint128ss_t_resize(status, uint128ss, length) status = f_uint128ss_resize(length, &uint128ss);
+ #define macro_f_uint128ss_t_adjust(status, uint128ss, length) status = f_uint128ss_adjust(length, &uint128ss);
- #define macro_f_uint128ss_t_delete_simple(uint128ss) f_type_uint128ss_resize(0, &uint128ss);
- #define macro_f_uint128ss_t_destroy_simple(uint128ss) f_type_uint128ss_adjust(0, &uint128ss);
+ #define macro_f_uint128ss_t_delete_simple(uint128ss) f_uint128ss_resize(0, &uint128ss);
+ #define macro_f_uint128ss_t_destroy_simple(uint128ss) f_uint128ss_adjust(0, &uint128ss);
- #define macro_f_uint128ss_t_increase(status, step, uint128ss) status = f_type_uint128ss_increase(step, &uint128ss);
- #define macro_f_uint128ss_t_increase_by(status, uint128ss, amount) status = f_type_uint128ss_increase_by(amount, &uint128ss);
- #define macro_f_uint128ss_t_decrease_by(status, uint128ss, amount) status = f_type_uint128ss_decrease_by(amount, &uint128ss);
- #define macro_f_uint128ss_t_decimate_by(status, uint128ss, amount) status = f_type_uint128ss_decimate_by(amount, &uint128ss);
+ #define macro_f_uint128ss_t_increase(status, step, uint128ss) status = f_uint128ss_increase(step, &uint128ss);
+ #define macro_f_uint128ss_t_increase_by(status, uint128ss, amount) status = f_uint128ss_increase_by(amount, &uint128ss);
+ #define macro_f_uint128ss_t_decrease_by(status, uint128ss, amount) status = f_uint128ss_decrease_by(amount, &uint128ss);
+ #define macro_f_uint128ss_t_decimate_by(status, uint128ss, amount) status = f_uint128ss_decimate_by(amount, &uint128ss);
#endif // _di_f_uint128ss_t_
#ifdef __cplusplus
extern "C" {
#endif
-#ifndef _di_f_type_array_lengths_adjust_
- f_status_t f_type_array_lengths_adjust(const f_array_length_t length, f_array_lengths_t *lengths) {
+#ifndef _di_f_array_lengths_adjust_
+ f_status_t f_array_lengths_adjust(const f_array_length_t length, f_array_lengths_t *lengths) {
#ifndef _di_level_0_parameter_checking_
if (!lengths) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
- return private_f_type_array_lengths_adjust(length, lengths);
+ return private_f_array_lengths_adjust(length, lengths);
}
-#endif // _di_f_type_array_lengths_adjust_
+#endif // _di_f_array_lengths_adjust_
-#ifndef _di_f_type_array_lengths_append_
- f_status_t f_type_array_lengths_append(const f_array_lengths_t source, f_array_lengths_t *destination) {
+#ifndef _di_f_array_lengths_append_
+ f_status_t f_array_lengths_append(const f_array_lengths_t source, f_array_lengths_t *destination) {
#ifndef _di_level_0_parameter_checking_
if (!destination) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
if (!source.used) return F_data_not;
- return private_f_type_array_lengths_append(source, destination);
+ return private_f_array_lengths_append(source, destination);
}
-#endif // _di_f_type_array_lengths_append_
+#endif // _di_f_array_lengths_append_
-#ifndef _di_f_type_array_lengths_decimate_by_
- f_status_t f_type_array_lengths_decimate_by(const f_array_length_t amount, f_array_lengths_t *lengths) {
+#ifndef _di_f_array_lengths_decimate_by_
+ f_status_t f_array_lengths_decimate_by(const f_array_length_t amount, f_array_lengths_t *lengths) {
#ifndef _di_level_0_parameter_checking_
if (!amount) return F_status_set_error(F_parameter);
if (!lengths) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
if (lengths->size - amount > 0) {
- return private_f_type_array_lengths_adjust(lengths->size - amount, lengths);
+ return private_f_array_lengths_adjust(lengths->size - amount, lengths);
}
- return private_f_type_array_lengths_adjust(0, lengths);
+ return private_f_array_lengths_adjust(0, lengths);
}
-#endif // _di_f_type_array_lengths_decimate_by_
+#endif // _di_f_array_lengths_decimate_by_
-#ifndef _di_f_type_array_lengths_decrease_by_
- f_status_t f_type_array_lengths_decrease_by(const f_array_length_t amount, f_array_lengths_t *lengths) {
+#ifndef _di_f_array_lengths_decrease_by_
+ f_status_t f_array_lengths_decrease_by(const f_array_length_t amount, f_array_lengths_t *lengths) {
#ifndef _di_level_0_parameter_checking_
if (!amount) return F_status_set_error(F_parameter);
if (!lengths) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
if (lengths->size - amount > 0) {
- return private_f_type_array_lengths_resize(lengths->size - amount, lengths);
+ return private_f_array_lengths_resize(lengths->size - amount, lengths);
}
- return private_f_type_array_lengths_resize(0, lengths);
+ return private_f_array_lengths_resize(0, lengths);
}
-#endif // _di_f_type_array_lengths_decrease_by_
+#endif // _di_f_array_lengths_decrease_by_
-#ifndef _di_f_type_array_lengths_increase_
- f_status_t f_type_array_lengths_increase(const uint16_t step, f_array_lengths_t *lengths) {
+#ifndef _di_f_array_lengths_increase_
+ f_status_t f_array_lengths_increase(const uint16_t step, f_array_lengths_t *lengths) {
#ifndef _di_level_0_parameter_checking_
if (!step) return F_status_set_error(F_parameter);
if (!lengths) return F_status_set_error(F_parameter);
size = F_array_length_t_size_d;
}
- return private_f_type_array_lengths_resize(size, lengths);
+ return private_f_array_lengths_resize(size, lengths);
}
return F_data_not;
}
-#endif // _di_f_type_array_lengths_increase_
+#endif // _di_f_array_lengths_increase_
-#ifndef _di_f_type_array_lengths_increase_by_
- f_status_t f_type_array_lengths_increase_by(const f_array_length_t amount, f_array_lengths_t *lengths) {
+#ifndef _di_f_array_lengths_increase_by_
+ f_status_t f_array_lengths_increase_by(const f_array_length_t amount, f_array_lengths_t *lengths) {
#ifndef _di_level_0_parameter_checking_
if (!amount) return F_status_set_error(F_parameter);
if (!lengths) return F_status_set_error(F_parameter);
return F_status_set_error(F_array_too_large);
}
- return private_f_type_array_lengths_resize(lengths->used + amount, lengths);
+ return private_f_array_lengths_resize(lengths->used + amount, lengths);
}
return F_data_not;
}
-#endif // _di_f_type_array_lengths_increase_by_
+#endif // _di_f_array_lengths_increase_by_
-#ifndef _di_f_type_array_lengths_resize_
- f_status_t f_type_array_lengths_resize(const f_array_length_t length, f_array_lengths_t *lengths) {
+#ifndef _di_f_array_lengths_resize_
+ f_status_t f_array_lengths_resize(const f_array_length_t length, f_array_lengths_t *lengths) {
#ifndef _di_level_0_parameter_checking_
if (!lengths) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
- return private_f_type_array_lengths_resize(length, lengths);
+ return private_f_array_lengths_resize(length, lengths);
}
-#endif // _di_f_type_array_lengths_resize_
+#endif // _di_f_array_lengths_resize_
-#ifndef _di_f_type_array_lengthss_adjust_
- f_status_t f_type_array_lengthss_adjust(const f_array_length_t length, f_array_lengthss_t *lengthss) {
+#ifndef _di_f_array_lengthss_adjust_
+ f_status_t f_array_lengthss_adjust(const f_array_length_t length, f_array_lengthss_t *lengthss) {
#ifndef _di_level_0_parameter_checking_
if (!lengthss) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
- return private_f_type_array_lengthss_adjust(length, lengthss);
+ return private_f_array_lengthss_adjust(length, lengthss);
}
-#endif // _di_f_type_array_lengthss_adjust_
+#endif // _di_f_array_lengthss_adjust_
-#ifndef _di_f_type_array_lengthss_append_
- f_status_t f_type_array_lengthss_append(const f_array_lengthss_t source, f_array_lengthss_t *destination) {
+#ifndef _di_f_array_lengthss_append_
+ f_status_t f_array_lengthss_append(const f_array_lengthss_t source, f_array_lengthss_t *destination) {
#ifndef _di_level_0_parameter_checking_
if (!destination) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
f_status_t status = F_none;
if (destination->used + source.used > destination->size) {
- status = private_f_type_array_lengthss_resize(destination->used + source.used, destination);
+ status = private_f_array_lengthss_resize(destination->used + source.used, destination);
if (F_status_is_error(status)) return status;
}
for (f_array_length_t i = 0; i < source.used; ++i, ++destination->used) {
- status = private_f_type_array_lengths_append(source.array[i], &destination->array[destination->used]);
+ status = private_f_array_lengths_append(source.array[i], &destination->array[destination->used]);
if (F_status_is_error(status)) return status;
} // for
return F_none;
}
-#endif // _di_f_type_array_lengthss_append_
+#endif // _di_f_array_lengthss_append_
-#ifndef _di_f_type_array_lengthss_decimate_by_
- f_status_t f_type_array_lengthss_decimate_by(const f_array_length_t amount, f_array_lengthss_t *lengthss) {
+#ifndef _di_f_array_lengthss_decimate_by_
+ f_status_t f_array_lengthss_decimate_by(const f_array_length_t amount, f_array_lengthss_t *lengthss) {
#ifndef _di_level_0_parameter_checking_
if (!amount) return F_status_set_error(F_parameter);
if (!lengthss) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
if (lengthss->size - amount > 0) {
- return private_f_type_array_lengthss_adjust(lengthss->size - amount, lengthss);
+ return private_f_array_lengthss_adjust(lengthss->size - amount, lengthss);
}
- return private_f_type_array_lengthss_adjust(0, lengthss);
+ return private_f_array_lengthss_adjust(0, lengthss);
}
-#endif // _di_f_type_array_lengthss_decimate_by_
+#endif // _di_f_array_lengthss_decimate_by_
-#ifndef _di_f_type_array_lengthss_decrease_by_
- f_status_t f_type_array_lengthss_decrease_by(const f_array_length_t amount, f_array_lengthss_t *lengthss) {
+#ifndef _di_f_array_lengthss_decrease_by_
+ f_status_t f_array_lengthss_decrease_by(const f_array_length_t amount, f_array_lengthss_t *lengthss) {
#ifndef _di_level_0_parameter_checking_
if (!amount) return F_status_set_error(F_parameter);
if (!lengthss) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
if (lengthss->size - amount > 0) {
- return private_f_type_array_lengthss_resize(lengthss->size - amount, lengthss);
+ return private_f_array_lengthss_resize(lengthss->size - amount, lengthss);
}
- return private_f_type_array_lengthss_resize(0, lengthss);
+ return private_f_array_lengthss_resize(0, lengthss);
}
-#endif // _di_f_type_array_lengthss_decrease_by_
+#endif // _di_f_array_lengthss_decrease_by_
-#ifndef _di_f_type_array_lengthss_increase_
- f_status_t f_type_array_lengthss_increase(const uint16_t step, f_array_lengthss_t *lengthss) {
+#ifndef _di_f_array_lengthss_increase_
+ f_status_t f_array_lengthss_increase(const uint16_t step, f_array_lengthss_t *lengthss) {
#ifndef _di_level_0_parameter_checking_
if (!step) return F_status_set_error(F_parameter);
if (!lengthss) return F_status_set_error(F_parameter);
size = F_array_length_t_size_d;
}
- return private_f_type_array_lengthss_resize(size, lengthss);
+ return private_f_array_lengthss_resize(size, lengthss);
}
return F_data_not;
}
-#endif // _di_f_type_array_lengthss_increase_
+#endif // _di_f_array_lengthss_increase_
-#ifndef _di_f_type_array_lengthss_increase_by_
- f_status_t f_type_array_lengthss_increase_by(const f_array_length_t amount, f_array_lengthss_t *lengthss) {
+#ifndef _di_f_array_lengthss_increase_by_
+ f_status_t f_array_lengthss_increase_by(const f_array_length_t amount, f_array_lengthss_t *lengthss) {
#ifndef _di_level_0_parameter_checking_
if (!amount) return F_status_set_error(F_parameter);
if (!lengthss) return F_status_set_error(F_parameter);
return F_status_set_error(F_array_too_large);
}
- return private_f_type_array_lengthss_resize(lengthss->used + amount, lengthss);
+ return private_f_array_lengthss_resize(lengthss->used + amount, lengthss);
}
return F_data_not;
}
-#endif // _di_f_type_array_lengthss_increase_by_
+#endif // _di_f_array_lengthss_increase_by_
-#ifndef _di_f_type_array_lengthss_resize_
- f_status_t f_type_array_lengthss_resize(const f_array_length_t length, f_array_lengthss_t *lengthss) {
+#ifndef _di_f_array_lengthss_resize_
+ f_status_t f_array_lengthss_resize(const f_array_length_t length, f_array_lengthss_t *lengthss) {
#ifndef _di_level_0_parameter_checking_
if (!lengthss) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
- return private_f_type_array_lengthss_resize(length, lengthss);
+ return private_f_array_lengthss_resize(length, lengthss);
}
-#endif // _di_f_type_array_lengthss_resize_
+#endif // _di_f_array_lengthss_resize_
#ifdef __cplusplus
} // extern "C"
*
* Errors (with error bit) from: f_memory_adjust().
*/
-#ifndef _di_f_type_array_lengths_adjust_
- extern f_status_t f_type_array_lengths_adjust(const f_array_length_t length, f_array_lengths_t *lengths);
-#endif // _di_f_type_array_lengths_adjust_
+#ifndef _di_f_array_lengths_adjust_
+ extern f_status_t f_array_lengths_adjust(const f_array_length_t length, f_array_lengths_t *lengths);
+#endif // _di_f_array_lengths_adjust_
/**
* Append the source lengths onto the destination.
*
* Errors (with error bit) from: f_memory_resize().
*/
-#ifndef _di_f_type_array_lengths_append_
- extern f_status_t f_type_array_lengths_append(const f_array_lengths_t source, f_array_lengths_t *destination);
-#endif // _di_f_type_array_lengths_append_
+#ifndef _di_f_array_lengths_append_
+ extern f_status_t f_array_lengths_append(const f_array_lengths_t source, f_array_lengths_t *destination);
+#endif // _di_f_array_lengths_append_
/**
* Resize the string lengths array to a smaller size.
*
* Errors (with error bit) from: f_memory_adjust().
*/
-#ifndef _di_f_type_array_lengths_decimate_by_
- extern f_status_t f_type_array_lengths_decimate_by(const f_array_length_t amount, f_array_lengths_t *lengths);
-#endif // _di_f_type_array_lengths_decimate_by_
+#ifndef _di_f_array_lengths_decimate_by_
+ extern f_status_t f_array_lengths_decimate_by(const f_array_length_t amount, f_array_lengths_t *lengths);
+#endif // _di_f_array_lengths_decimate_by_
/**
* Resize the string lengths array to a smaller size.
*
* Errors (with error bit) from: f_memory_resize().
*/
-#ifndef _di_f_type_array_lengths_decrease_by_
- extern f_status_t f_type_array_lengths_decrease_by(const f_array_length_t amount, f_array_lengths_t *lengths);
-#endif // _di_f_type_array_lengths_decrease_by_
+#ifndef _di_f_array_lengths_decrease_by_
+ extern f_status_t f_array_lengths_decrease_by(const f_array_length_t amount, f_array_lengths_t *lengths);
+#endif // _di_f_array_lengths_decrease_by_
/**
* Increase the size of the string lengths array, but only if necesary.
*
* Errors (with error bit) from: f_memory_resize().
*/
-#ifndef _di_f_type_array_lengths_increase_
- extern f_status_t f_type_array_lengths_increase(const uint16_t step, f_array_lengths_t *lengths);
-#endif // _di_f_type_array_lengths_increase_
+#ifndef _di_f_array_lengths_increase_
+ extern f_status_t f_array_lengths_increase(const uint16_t step, f_array_lengths_t *lengths);
+#endif // _di_f_array_lengths_increase_
/**
* Resize the string lengths array to a larger size.
*
* Errors (with error bit) from: f_memory_resize().
*/
-#ifndef _di_f_type_array_lengths_increase_by_
- extern f_status_t f_type_array_lengths_increase_by(const f_array_length_t amount, f_array_lengths_t *lengths);
-#endif // _di_f_type_array_lengths_increase_by_
+#ifndef _di_f_array_lengths_increase_by_
+ extern f_status_t f_array_lengths_increase_by(const f_array_length_t amount, f_array_lengths_t *lengths);
+#endif // _di_f_array_lengths_increase_by_
/**
* Resize the string lengths array.
*
* Errors (with error bit) from: f_memory_resize().
*/
-#ifndef _di_f_type_array_lengths_resize_
- extern f_status_t f_type_array_lengths_resize(const f_array_length_t length, f_array_lengths_t *lengths);
-#endif // _di_f_type_array_lengths_resize_
+#ifndef _di_f_array_lengths_resize_
+ extern f_status_t f_array_lengths_resize(const f_array_length_t length, f_array_lengths_t *lengths);
+#endif // _di_f_array_lengths_resize_
/**
* Resize the string lengthss array.
* Errors (with error bit) from: f_memory_adjust().
* Errors (with error bit) from: f_memory_destroy().
*/
-#ifndef _di_f_type_array_lengthss_adjust_
- extern f_status_t f_type_array_lengthss_adjust(const f_array_length_t length, f_array_lengthss_t *lengthss);
-#endif // _di_f_type_array_lengthss_adjust_
+#ifndef _di_f_array_lengthss_adjust_
+ extern f_status_t f_array_lengthss_adjust(const f_array_length_t length, f_array_lengthss_t *lengthss);
+#endif // _di_f_array_lengthss_adjust_
/**
* Append the source lengthss onto the destination.
*
* Errors (with error bit) from: f_memory_resize().
*/
-#ifndef _di_f_type_array_lengthss_append_
- extern f_status_t f_type_array_lengthss_append(const f_array_lengthss_t source, f_array_lengthss_t *destination);
-#endif // _di_f_type_array_lengthss_append_
+#ifndef _di_f_array_lengthss_append_
+ extern f_status_t f_array_lengthss_append(const f_array_lengthss_t source, f_array_lengthss_t *destination);
+#endif // _di_f_array_lengthss_append_
/**
* Resize the string lengthss array.
* Errors (with error bit) from: f_memory_adjust().
* Errors (with error bit) from: f_memory_destroy().
*/
-#ifndef _di_f_type_array_lengthss_adjust_
- extern f_status_t f_type_array_lengthss_adjust(const f_array_length_t length, f_array_lengthss_t *lengthss);
-#endif // _di_f_type_array_lengthss_adjust_
+#ifndef _di_f_array_lengthss_adjust_
+ extern f_status_t f_array_lengthss_adjust(const f_array_length_t length, f_array_lengthss_t *lengthss);
+#endif // _di_f_array_lengthss_adjust_
/**
* Resize the string lengthss array to a smaller size.
* Errors (with error bit) from: f_memory_adjust().
* Errors (with error bit) from: f_memory_destroy().
*/
-#ifndef _di_f_type_array_lengthss_decimate_by_
- extern f_status_t f_type_array_lengthss_decimate_by(const f_array_length_t amount, f_array_lengthss_t *lengthss);
-#endif // _di_f_type_array_lengthss_decimate_by_
+#ifndef _di_f_array_lengthss_decimate_by_
+ extern f_status_t f_array_lengthss_decimate_by(const f_array_length_t amount, f_array_lengthss_t *lengthss);
+#endif // _di_f_array_lengthss_decimate_by_
/**
* Resize the string lengthss array to a smaller size.
* Errors (with error bit) from: f_memory_delete().
* Errors (with error bit) from: f_memory_resize().
*/
-#ifndef _di_f_type_array_lengthss_decrease_by_
- extern f_status_t f_type_array_lengthss_decrease_by(const f_array_length_t amount, f_array_lengthss_t *lengthss);
-#endif // _di_f_type_array_lengthss_decrease_by_
+#ifndef _di_f_array_lengthss_decrease_by_
+ extern f_status_t f_array_lengthss_decrease_by(const f_array_length_t amount, f_array_lengthss_t *lengthss);
+#endif // _di_f_array_lengthss_decrease_by_
/**
* Increase the size of the string lengthss array, but only if necessary.
*
* Errors (with error bit) from: f_memory_resize().
*/
-#ifndef _di_f_type_array_lengthss_increase_
- extern f_status_t f_type_array_lengthss_increase(const uint16_t step, f_array_lengthss_t *lengthss);
-#endif // _di_f_type_array_lengthss_increase_
+#ifndef _di_f_array_lengthss_increase_
+ extern f_status_t f_array_lengthss_increase(const uint16_t step, f_array_lengthss_t *lengthss);
+#endif // _di_f_array_lengthss_increase_
/**
* Resize the string lengthss array to a larger size.
*
* Errors (with error bit) from: f_memory_resize().
*/
-#ifndef _di_f_type_array_lengthss_increase_by_
- extern f_status_t f_type_array_lengthss_increase_by(const f_array_length_t amount, f_array_lengthss_t *lengthss);
-#endif // _di_f_type_array_lengthss_increase_by_
+#ifndef _di_f_array_lengthss_increase_by_
+ extern f_status_t f_array_lengthss_increase_by(const f_array_length_t amount, f_array_lengthss_t *lengthss);
+#endif // _di_f_array_lengthss_increase_by_
/**
* Resize the string lengthss array.
* Errors (with error bit) from: f_memory_delete().
* Errors (with error bit) from: f_memory_resize().
*/
-#ifndef _di_f_type_array_lengthss_resize_
- extern f_status_t f_type_array_lengthss_resize(const f_array_length_t length, f_array_lengthss_t *lengthss);
-#endif // _di_f_type_array_lengthss_resize_
+#ifndef _di_f_array_lengthss_resize_
+ extern f_status_t f_array_lengthss_resize(const f_array_length_t length, f_array_lengthss_t *lengthss);
+#endif // _di_f_array_lengthss_resize_
#ifdef __cplusplus
} // extern "C"
extern "C" {
#endif
-#ifndef _di_f_type_cells_adjust_
- f_status_t f_type_cells_adjust(const f_array_length_t length, f_cells_t *cells) {
+#ifndef _di_f_cells_adjust_
+ f_status_t f_cells_adjust(const f_array_length_t length, f_cells_t *cells) {
#ifndef _di_level_0_parameter_checking_
if (!cells) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
- return private_f_type_cells_adjust(length, cells);
+ return private_f_cells_adjust(length, cells);
}
-#endif // _di_f_type_cells_adjust_
+#endif // _di_f_cells_adjust_
-#ifndef _di_f_type_cells_append_
- f_status_t f_type_cells_append(const f_cells_t source, f_cells_t *destination) {
+#ifndef _di_f_cells_append_
+ f_status_t f_cells_append(const f_cells_t source, f_cells_t *destination) {
#ifndef _di_level_0_parameter_checking_
if (!destination) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
if (!source.used) return F_data_not;
- return private_f_type_cells_append(source, destination);
+ return private_f_cells_append(source, destination);
}
-#endif // _di_f_type_cells_append_
+#endif // _di_f_cells_append_
-#ifndef _di_f_type_cells_decimate_by_
- f_status_t f_type_cells_decimate_by(const f_array_length_t amount, f_cells_t *cells) {
+#ifndef _di_f_cells_decimate_by_
+ f_status_t f_cells_decimate_by(const f_array_length_t amount, f_cells_t *cells) {
#ifndef _di_level_0_parameter_checking_
if (!amount) return F_status_set_error(F_parameter);
if (!cells) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
if (cells->size - amount > 0) {
- return private_f_type_cells_adjust(cells->size - amount, cells);
+ return private_f_cells_adjust(cells->size - amount, cells);
}
- return private_f_type_cells_adjust(0, cells);
+ return private_f_cells_adjust(0, cells);
}
-#endif // _di_f_type_cells_decimate_by_
+#endif // _di_f_cells_decimate_by_
-#ifndef _di_f_type_cells_decrease_by_
- f_status_t f_type_cells_decrease_by(const f_array_length_t amount, f_cells_t *cells) {
+#ifndef _di_f_cells_decrease_by_
+ f_status_t f_cells_decrease_by(const f_array_length_t amount, f_cells_t *cells) {
#ifndef _di_level_0_parameter_checking_
if (!amount) return F_status_set_error(F_parameter);
if (!cells) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
if (cells->size - amount > 0) {
- return private_f_type_cells_resize(cells->size - amount, cells);
+ return private_f_cells_resize(cells->size - amount, cells);
}
- return private_f_type_cells_resize(0, cells);
+ return private_f_cells_resize(0, cells);
}
-#endif // _di_f_type_cells_decrease_by_
+#endif // _di_f_cells_decrease_by_
-#ifndef _di_f_type_cells_increase_
- f_status_t f_type_cells_increase(const uint16_t step, f_cells_t *cells) {
+#ifndef _di_f_cells_increase_
+ f_status_t f_cells_increase(const uint16_t step, f_cells_t *cells) {
#ifndef _di_level_0_parameter_checking_
if (!step) return F_status_set_error(F_parameter);
if (!cells) return F_status_set_error(F_parameter);
size = F_array_length_t_size_d;
}
- return private_f_type_cells_resize(size, cells);
+ return private_f_cells_resize(size, cells);
}
return F_data_not;
}
-#endif // _di_f_type_cells_increase_
+#endif // _di_f_cells_increase_
-#ifndef _di_f_type_cells_increase_by_
- f_status_t f_type_cells_increase_by(const f_array_length_t amount, f_cells_t *cells) {
+#ifndef _di_f_cells_increase_by_
+ f_status_t f_cells_increase_by(const f_array_length_t amount, f_cells_t *cells) {
#ifndef _di_level_0_parameter_checking_
if (!amount) return F_status_set_error(F_parameter);
if (!cells) return F_status_set_error(F_parameter);
return F_status_set_error(F_array_too_large);
}
- return private_f_type_cells_resize(cells->used + amount, cells);
+ return private_f_cells_resize(cells->used + amount, cells);
}
return F_data_not;
}
-#endif // _di_f_type_cells_increase_by_
+#endif // _di_f_cells_increase_by_
-#ifndef _di_f_type_cells_resize_
- f_status_t f_type_cells_resize(const f_array_length_t length, f_cells_t *cells) {
+#ifndef _di_f_cells_resize_
+ f_status_t f_cells_resize(const f_array_length_t length, f_cells_t *cells) {
#ifndef _di_level_0_parameter_checking_
if (!cells) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
- return private_f_type_cells_resize(length, cells);
+ return private_f_cells_resize(length, cells);
}
-#endif // _di_f_type_cells_resize_
+#endif // _di_f_cells_resize_
-#ifndef _di_f_type_cellss_adjust_
- f_status_t f_type_cellss_adjust(const f_array_length_t length, f_cellss_t *cellss) {
+#ifndef _di_f_cellss_adjust_
+ f_status_t f_cellss_adjust(const f_array_length_t length, f_cellss_t *cellss) {
#ifndef _di_level_0_parameter_checking_
if (!cellss) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
- return private_f_type_cellss_adjust(length, cellss);
+ return private_f_cellss_adjust(length, cellss);
}
-#endif // _di_f_type_cellss_adjust_
+#endif // _di_f_cellss_adjust_
-#ifndef _di_f_type_cellss_append_
- f_status_t f_type_cellss_append(const f_cellss_t source, f_cellss_t *destination) {
+#ifndef _di_f_cellss_append_
+ f_status_t f_cellss_append(const f_cellss_t source, f_cellss_t *destination) {
#ifndef _di_level_0_parameter_checking_
if (!destination) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
f_status_t status = F_none;
if (destination->used + source.used > destination->size) {
- status = private_f_type_cellss_resize(destination->used + source.used, destination);
+ status = private_f_cellss_resize(destination->used + source.used, destination);
if (F_status_is_error(status)) return status;
}
for (f_array_length_t i = 0; i < source.used; ++i, ++destination->used) {
- status = private_f_type_cells_append(source.array[i], &destination->array[destination->used]);
+ status = private_f_cells_append(source.array[i], &destination->array[destination->used]);
if (F_status_is_error(status)) return status;
} // for
return F_none;
}
-#endif // _di_f_type_cellss_append_
+#endif // _di_f_cellss_append_
-#ifndef _di_f_type_cellss_decimate_by_
- f_status_t f_type_cellss_decimate_by(const f_array_length_t amount, f_cellss_t *cellss) {
+#ifndef _di_f_cellss_decimate_by_
+ f_status_t f_cellss_decimate_by(const f_array_length_t amount, f_cellss_t *cellss) {
#ifndef _di_level_0_parameter_checking_
if (!amount) return F_status_set_error(F_parameter);
if (!cellss) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
if (cellss->size - amount > 0) {
- return private_f_type_cellss_adjust(cellss->size - amount, cellss);
+ return private_f_cellss_adjust(cellss->size - amount, cellss);
}
- return private_f_type_cellss_adjust(0, cellss);
+ return private_f_cellss_adjust(0, cellss);
}
-#endif // _di_f_type_cellss_decimate_by_
+#endif // _di_f_cellss_decimate_by_
-#ifndef _di_f_type_cellss_decrease_by_
- f_status_t f_type_cellss_decrease_by(const f_array_length_t amount, f_cellss_t *cellss) {
+#ifndef _di_f_cellss_decrease_by_
+ f_status_t f_cellss_decrease_by(const f_array_length_t amount, f_cellss_t *cellss) {
#ifndef _di_level_0_parameter_checking_
if (!amount) return F_status_set_error(F_parameter);
if (!cellss) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
if (cellss->size - amount > 0) {
- return private_f_type_cellss_resize(cellss->size - amount, cellss);
+ return private_f_cellss_resize(cellss->size - amount, cellss);
}
- return private_f_type_cellss_resize(0, cellss);
+ return private_f_cellss_resize(0, cellss);
}
-#endif // _di_f_type_cellss_decrease_by_
+#endif // _di_f_cellss_decrease_by_
-#ifndef _di_f_type_cellss_increase_
- f_status_t f_type_cellss_increase(const uint16_t step, f_cellss_t *cellss) {
+#ifndef _di_f_cellss_increase_
+ f_status_t f_cellss_increase(const uint16_t step, f_cellss_t *cellss) {
#ifndef _di_level_0_parameter_checking_
if (!step) return F_status_set_error(F_parameter);
if (!cellss) return F_status_set_error(F_parameter);
size = F_array_length_t_size_d;
}
- return private_f_type_cellss_resize(size, cellss);
+ return private_f_cellss_resize(size, cellss);
}
return F_data_not;
}
-#endif // _di_f_type_cellss_increase_
+#endif // _di_f_cellss_increase_
-#ifndef _di_f_type_cellss_increase_by_
- f_status_t f_type_cellss_increase_by(const f_array_length_t amount, f_cellss_t *cellss) {
+#ifndef _di_f_cellss_increase_by_
+ f_status_t f_cellss_increase_by(const f_array_length_t amount, f_cellss_t *cellss) {
#ifndef _di_level_0_parameter_checking_
if (!amount) return F_status_set_error(F_parameter);
if (!cellss) return F_status_set_error(F_parameter);
return F_status_set_error(F_array_too_large);
}
- return private_f_type_cellss_resize(cellss->used + amount, cellss);
+ return private_f_cellss_resize(cellss->used + amount, cellss);
}
return F_data_not;
}
-#endif // _di_f_type_cellss_increase_by_
+#endif // _di_f_cellss_increase_by_
-#ifndef _di_f_type_cellss_resize_
- f_status_t f_type_cellss_resize(const f_array_length_t length, f_cellss_t *cellss) {
+#ifndef _di_f_cellss_resize_
+ f_status_t f_cellss_resize(const f_array_length_t length, f_cellss_t *cellss) {
#ifndef _di_level_0_parameter_checking_
if (!cellss) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
- return private_f_type_cellss_resize(length, cellss);
+ return private_f_cellss_resize(length, cellss);
}
-#endif // _di_f_type_cellss_resize_
+#endif // _di_f_cellss_resize_
#ifdef __cplusplus
} // extern "C"
*
* Errors (with error bit) from: f_memory_adjust().
*/
-#ifndef _di_f_type_cells_adjust_
- extern f_status_t f_type_cells_adjust(const f_array_length_t length, f_cells_t *cells);
-#endif // _di_f_type_cells_adjust_
+#ifndef _di_f_cells_adjust_
+ extern f_status_t f_cells_adjust(const f_array_length_t length, f_cells_t *cells);
+#endif // _di_f_cells_adjust_
/**
* Append the source cells onto the destination.
*
* Errors (with error bit) from: f_memory_resize().
*/
-#ifndef _di_f_type_cells_append_
- extern f_status_t f_type_cells_append(const f_cells_t source, f_cells_t *destination);
-#endif // _di_f_type_cells_append_
+#ifndef _di_f_cells_append_
+ extern f_status_t f_cells_append(const f_cells_t source, f_cells_t *destination);
+#endif // _di_f_cells_append_
/**
* Resize the string cells array to a smaller size.
*
* Errors (with error bit) from: f_memory_adjust().
*/
-#ifndef _di_f_type_cells_decimate_by_
- extern f_status_t f_type_cells_decimate_by(const f_array_length_t amount, f_cells_t *cells);
-#endif // _di_f_type_cells_decimate_by_
+#ifndef _di_f_cells_decimate_by_
+ extern f_status_t f_cells_decimate_by(const f_array_length_t amount, f_cells_t *cells);
+#endif // _di_f_cells_decimate_by_
/**
* Resize the string cells array to a smaller size.
*
* Errors (with error bit) from: f_memory_resize().
*/
-#ifndef _di_f_type_cells_decrease_by_
- extern f_status_t f_type_cells_decrease_by(const f_array_length_t amount, f_cells_t *cells);
-#endif // _di_f_type_cells_decrease_by_
+#ifndef _di_f_cells_decrease_by_
+ extern f_status_t f_cells_decrease_by(const f_array_length_t amount, f_cells_t *cells);
+#endif // _di_f_cells_decrease_by_
/**
* Increase the size of the string cells array, but only if necesary.
*
* Errors (with error bit) from: f_memory_resize().
*/
-#ifndef _di_f_type_cells_increase_
- extern f_status_t f_type_cells_increase(const uint16_t step, f_cells_t *cells);
-#endif // _di_f_type_cells_increase_
+#ifndef _di_f_cells_increase_
+ extern f_status_t f_cells_increase(const uint16_t step, f_cells_t *cells);
+#endif // _di_f_cells_increase_
/**
* Resize the string cells array to a larger size.
*
* Errors (with error bit) from: f_memory_resize().
*/
-#ifndef _di_f_type_cells_increase_by_
- extern f_status_t f_type_cells_increase_by(const f_array_length_t amount, f_cells_t *cells);
-#endif // _di_f_type_cells_increase_by_
+#ifndef _di_f_cells_increase_by_
+ extern f_status_t f_cells_increase_by(const f_array_length_t amount, f_cells_t *cells);
+#endif // _di_f_cells_increase_by_
/**
* Resize the string cells array.
*
* Errors (with error bit) from: f_memory_resize().
*/
-#ifndef _di_f_type_cells_resize_
- extern f_status_t f_type_cells_resize(const f_array_length_t length, f_cells_t *cells);
-#endif // _di_f_type_cells_resize_
+#ifndef _di_f_cells_resize_
+ extern f_status_t f_cells_resize(const f_array_length_t length, f_cells_t *cells);
+#endif // _di_f_cells_resize_
/**
* Resize the string cellss array.
* Errors (with error bit) from: f_memory_adjust().
* Errors (with error bit) from: f_memory_destroy().
*/
-#ifndef _di_f_type_cellss_adjust_
- extern f_status_t f_type_cellss_adjust(const f_array_length_t length, f_cellss_t *cellss);
-#endif // _di_f_type_cellss_adjust_
+#ifndef _di_f_cellss_adjust_
+ extern f_status_t f_cellss_adjust(const f_array_length_t length, f_cellss_t *cellss);
+#endif // _di_f_cellss_adjust_
/**
* Append the source cellss onto the destination.
*
* Errors (with error bit) from: f_memory_resize().
*/
-#ifndef _di_f_type_cellss_append_
- extern f_status_t f_type_cellss_append(const f_cellss_t source, f_cellss_t *destination);
-#endif // _di_f_type_cellss_append_
+#ifndef _di_f_cellss_append_
+ extern f_status_t f_cellss_append(const f_cellss_t source, f_cellss_t *destination);
+#endif // _di_f_cellss_append_
/**
* Resize the string cellss array.
* Errors (with error bit) from: f_memory_adjust().
* Errors (with error bit) from: f_memory_destroy().
*/
-#ifndef _di_f_type_cellss_adjust_
- extern f_status_t f_type_cellss_adjust(const f_array_length_t length, f_cellss_t *cellss);
-#endif // _di_f_type_cellss_adjust_
+#ifndef _di_f_cellss_adjust_
+ extern f_status_t f_cellss_adjust(const f_array_length_t length, f_cellss_t *cellss);
+#endif // _di_f_cellss_adjust_
/**
* Resize the string cellss array to a smaller size.
* Errors (with error bit) from: f_memory_adjust().
* Errors (with error bit) from: f_memory_destroy().
*/
-#ifndef _di_f_type_cellss_decimate_by_
- extern f_status_t f_type_cellss_decimate_by(const f_array_length_t amount, f_cellss_t *cellss);
-#endif // _di_f_type_cellss_decimate_by_
+#ifndef _di_f_cellss_decimate_by_
+ extern f_status_t f_cellss_decimate_by(const f_array_length_t amount, f_cellss_t *cellss);
+#endif // _di_f_cellss_decimate_by_
/**
* Resize the string cellss array to a smaller size.
* Errors (with error bit) from: f_memory_delete().
* Errors (with error bit) from: f_memory_resize().
*/
-#ifndef _di_f_type_cellss_decrease_by_
- extern f_status_t f_type_cellss_decrease_by(const f_array_length_t amount, f_cellss_t *cellss);
-#endif // _di_f_type_cellss_decrease_by_
+#ifndef _di_f_cellss_decrease_by_
+ extern f_status_t f_cellss_decrease_by(const f_array_length_t amount, f_cellss_t *cellss);
+#endif // _di_f_cellss_decrease_by_
/**
* Increase the size of the string cellss array, but only if necessary.
*
* Errors (with error bit) from: f_memory_resize().
*/
-#ifndef _di_f_type_cellss_increase_
- extern f_status_t f_type_cellss_increase(const uint16_t step, f_cellss_t *cellss);
-#endif // _di_f_type_cellss_increase_
+#ifndef _di_f_cellss_increase_
+ extern f_status_t f_cellss_increase(const uint16_t step, f_cellss_t *cellss);
+#endif // _di_f_cellss_increase_
/**
* Resize the string cellss array to a larger size.
*
* Errors (with error bit) from: f_memory_resize().
*/
-#ifndef _di_f_type_cellss_increase_by_
- extern f_status_t f_type_cellss_increase_by(const f_array_length_t amount, f_cellss_t *cellss);
-#endif // _di_f_type_cellss_increase_by_
+#ifndef _di_f_cellss_increase_by_
+ extern f_status_t f_cellss_increase_by(const f_array_length_t amount, f_cellss_t *cellss);
+#endif // _di_f_cellss_increase_by_
/**
* Resize the string cellss array.
* Errors (with error bit) from: f_memory_delete().
* Errors (with error bit) from: f_memory_resize().
*/
-#ifndef _di_f_type_cellss_resize_
- extern f_status_t f_type_cellss_resize(const f_array_length_t length, f_cellss_t *cellss);
-#endif // _di_f_type_cellss_resize_
+#ifndef _di_f_cellss_resize_
+ extern f_status_t f_cellss_resize(const f_array_length_t length, f_cellss_t *cellss);
+#endif // _di_f_cellss_resize_
#ifdef __cplusplus
} // extern "C"
extern "C" {
#endif
-#ifndef _di_f_type_fll_ids_adjust_
- f_status_t f_type_fll_ids_adjust(const f_array_length_t length, f_fll_ids_t *ids) {
+#ifndef _di_f_fll_ids_adjust_
+ f_status_t f_fll_ids_adjust(const f_array_length_t length, f_fll_ids_t *ids) {
#ifndef _di_level_0_parameter_checking_
if (!ids) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
- return private_f_type_fll_ids_adjust(length, ids);
+ return private_f_fll_ids_adjust(length, ids);
}
-#endif // _di_f_type_fll_ids_adjust_
+#endif // _di_f_fll_ids_adjust_
-#ifndef _di_f_type_fll_ids_append_
- f_status_t f_type_fll_ids_append(const f_fll_ids_t source, f_fll_ids_t *destination) {
+#ifndef _di_f_fll_ids_append_
+ f_status_t f_fll_ids_append(const f_fll_ids_t source, f_fll_ids_t *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_type_fll_ids_append(source, destination);
+ return private_f_fll_ids_append(source, destination);
}
-#endif // _di_f_type_fll_ids_append_
+#endif // _di_f_fll_ids_append_
-#ifndef _di_f_type_fll_ids_decimate_by_
- f_status_t f_type_fll_ids_decimate_by(const f_array_length_t amount, f_fll_ids_t *ids) {
+#ifndef _di_f_fll_ids_decimate_by_
+ f_status_t f_fll_ids_decimate_by(const f_array_length_t amount, f_fll_ids_t *ids) {
#ifndef _di_level_0_parameter_checking_
if (!amount) return F_status_set_error(F_parameter);
if (!ids) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
if (ids->size - amount > 0) {
- return private_f_type_fll_ids_adjust(ids->size - amount, ids);
+ return private_f_fll_ids_adjust(ids->size - amount, ids);
}
- return private_f_type_fll_ids_adjust(0, ids);
+ return private_f_fll_ids_adjust(0, ids);
}
-#endif // _di_f_type_fll_ids_decimate_by_
+#endif // _di_f_fll_ids_decimate_by_
-#ifndef _di_f_type_fll_ids_decrease_by_
- f_status_t f_type_fll_ids_decrease_by(const f_array_length_t amount, f_fll_ids_t *ids) {
+#ifndef _di_f_fll_ids_decrease_by_
+ f_status_t f_fll_ids_decrease_by(const f_array_length_t amount, f_fll_ids_t *ids) {
#ifndef _di_level_0_parameter_checking_
if (!amount) return F_status_set_error(F_parameter);
if (!ids) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
if (ids->size - amount > 0) {
- return private_f_type_fll_ids_resize(ids->size - amount, ids);
+ return private_f_fll_ids_resize(ids->size - amount, ids);
}
- return private_f_type_fll_ids_resize(0, ids);
+ return private_f_fll_ids_resize(0, ids);
}
-#endif // _di_f_type_fll_ids_decrease_by_
+#endif // _di_f_fll_ids_decrease_by_
-#ifndef _di_f_type_fll_ids_increase_
- f_status_t f_type_fll_ids_increase(const uint16_t step, f_fll_ids_t *ids) {
+#ifndef _di_f_fll_ids_increase_
+ f_status_t f_fll_ids_increase(const uint16_t step, f_fll_ids_t *ids) {
#ifndef _di_level_0_parameter_checking_
if (!step) return F_status_set_error(F_parameter);
if (!ids) return F_status_set_error(F_parameter);
size = F_array_length_t_size_d;
}
- return private_f_type_fll_ids_resize(size, ids);
+ return private_f_fll_ids_resize(size, ids);
}
return F_data_not;
}
-#endif // _di_f_type_fll_ids_increase_
+#endif // _di_f_fll_ids_increase_
-#ifndef _di_f_type_fll_ids_increase_by_
- f_status_t f_type_fll_ids_increase_by(const f_array_length_t amount, f_fll_ids_t *ids) {
+#ifndef _di_f_fll_ids_increase_by_
+ f_status_t f_fll_ids_increase_by(const f_array_length_t amount, f_fll_ids_t *ids) {
#ifndef _di_level_0_parameter_checking_
if (!amount) return F_status_set_error(F_parameter);
if (!ids) return F_status_set_error(F_parameter);
return F_status_set_error(F_array_too_large);
}
- return private_f_type_fll_ids_resize(ids->used + amount, ids);
+ return private_f_fll_ids_resize(ids->used + amount, ids);
}
return F_data_not;
}
-#endif // _di_f_type_fll_ids_increase_by_
+#endif // _di_f_fll_ids_increase_by_
-#ifndef _di_f_type_fll_ids_resize_
- f_status_t f_type_fll_ids_resize(const f_array_length_t length, f_fll_ids_t *ids) {
+#ifndef _di_f_fll_ids_resize_
+ f_status_t f_fll_ids_resize(const f_array_length_t length, f_fll_ids_t *ids) {
#ifndef _di_level_0_parameter_checking_
if (!ids) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
- return private_f_type_fll_ids_resize(length, ids);
+ return private_f_fll_ids_resize(length, ids);
}
-#endif // _di_f_type_fll_ids_resize_
+#endif // _di_f_fll_ids_resize_
-#ifndef _di_f_type_fll_idss_adjust_
- f_status_t f_type_fll_idss_adjust(const f_array_length_t length, f_fll_idss_t *idss) {
+#ifndef _di_f_fll_idss_adjust_
+ f_status_t f_fll_idss_adjust(const f_array_length_t length, f_fll_idss_t *idss) {
#ifndef _di_level_0_parameter_checking_
if (!idss) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
- return private_f_type_fll_idss_adjust(length, idss);
+ return private_f_fll_idss_adjust(length, idss);
}
-#endif // _di_f_type_fll_idss_adjust_
+#endif // _di_f_fll_idss_adjust_
-#ifndef _di_f_type_fll_idss_append_
- f_status_t f_type_fll_idss_append(const f_fll_idss_t source, f_fll_idss_t *destination) {
+#ifndef _di_f_fll_idss_append_
+ f_status_t f_fll_idss_append(const f_fll_idss_t source, f_fll_idss_t *destination) {
#ifndef _di_level_0_parameter_checking_
if (!destination) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
f_status_t status = F_none;
if (destination->used + source.used > destination->size) {
- status = private_f_type_fll_idss_resize(destination->used + source.used, destination);
+ status = private_f_fll_idss_resize(destination->used + source.used, destination);
if (F_status_is_error(status)) return status;
}
for (f_array_length_t i = 0; i < source.used; ++i, ++destination->used) {
- status = private_f_type_fll_ids_append(source.array[i], &destination->array[destination->used]);
+ status = private_f_fll_ids_append(source.array[i], &destination->array[destination->used]);
if (F_status_is_error(status)) return status;
} // for
return F_none;
}
-#endif // _di_f_type_fll_idss_append_
+#endif // _di_f_fll_idss_append_
-#ifndef _di_f_type_fll_idss_decimate_by_
- f_status_t f_type_fll_idss_decimate_by(const f_array_length_t amount, f_fll_idss_t *idss) {
+#ifndef _di_f_fll_idss_decimate_by_
+ f_status_t f_fll_idss_decimate_by(const f_array_length_t amount, f_fll_idss_t *idss) {
#ifndef _di_level_0_parameter_checking_
if (!amount) return F_status_set_error(F_parameter);
if (!idss) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
if (idss->size - amount > 0) {
- return private_f_type_fll_idss_adjust(idss->size - amount, idss);
+ return private_f_fll_idss_adjust(idss->size - amount, idss);
}
- return private_f_type_fll_idss_adjust(0, idss);
+ return private_f_fll_idss_adjust(0, idss);
}
-#endif // _di_f_type_fll_idss_decimate_by_
+#endif // _di_f_fll_idss_decimate_by_
-#ifndef _di_f_type_fll_idss_decrease_by_
- f_status_t f_type_fll_idss_decrease_by(const f_array_length_t amount, f_fll_idss_t *idss) {
+#ifndef _di_f_fll_idss_decrease_by_
+ f_status_t f_fll_idss_decrease_by(const f_array_length_t amount, f_fll_idss_t *idss) {
#ifndef _di_level_0_parameter_checking_
if (!amount) return F_status_set_error(F_parameter);
if (!idss) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
if (idss->size - amount > 0) {
- return private_f_type_fll_idss_resize(idss->size - amount, idss);
+ return private_f_fll_idss_resize(idss->size - amount, idss);
}
- return private_f_type_fll_idss_resize(0, idss);
+ return private_f_fll_idss_resize(0, idss);
}
-#endif // _di_f_type_fll_idss_decrease_by_
+#endif // _di_f_fll_idss_decrease_by_
-#ifndef _di_f_type_fll_idss_increase_
- f_status_t f_type_fll_idss_increase(const uint16_t step, f_fll_idss_t *idss) {
+#ifndef _di_f_fll_idss_increase_
+ f_status_t f_fll_idss_increase(const uint16_t step, f_fll_idss_t *idss) {
#ifndef _di_level_0_parameter_checking_
if (!step) return F_status_set_error(F_parameter);
if (!idss) return F_status_set_error(F_parameter);
size = F_array_length_t_size_d;
}
- return private_f_type_fll_idss_resize(size, idss);
+ return private_f_fll_idss_resize(size, idss);
}
return F_data_not;
}
-#endif // _di_f_type_fll_idss_increase_
+#endif // _di_f_fll_idss_increase_
-#ifndef _di_f_type_fll_idss_increase_by_
- f_status_t f_type_fll_idss_increase_by(const f_array_length_t amount, f_fll_idss_t *idss) {
+#ifndef _di_f_fll_idss_increase_by_
+ f_status_t f_fll_idss_increase_by(const f_array_length_t amount, f_fll_idss_t *idss) {
#ifndef _di_level_0_parameter_checking_
if (!amount) return F_status_set_error(F_parameter);
if (!idss) return F_status_set_error(F_parameter);
return F_status_set_error(F_array_too_large);
}
- return private_f_type_fll_idss_resize(idss->used + amount, idss);
+ return private_f_fll_idss_resize(idss->used + amount, idss);
}
return F_data_not;
}
-#endif // _di_f_type_fll_idss_increase_by_
+#endif // _di_f_fll_idss_increase_by_
-#ifndef _di_f_type_fll_idss_resize_
- f_status_t f_type_fll_idss_resize(const f_array_length_t length, f_fll_idss_t *idss) {
+#ifndef _di_f_fll_idss_resize_
+ f_status_t f_fll_idss_resize(const f_array_length_t length, f_fll_idss_t *idss) {
#ifndef _di_level_0_parameter_checking_
if (!idss) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
- return private_f_type_fll_idss_resize(length, idss);
+ return private_f_fll_idss_resize(length, idss);
}
-#endif // _di_f_type_fll_idss_resize_
+#endif // _di_f_fll_idss_resize_
#ifdef __cplusplus
} // extern "C"
*
* Errors (with error bit) from: f_memory_adjust().
*/
-#ifndef _di_f_type_fll_ids_adjust_
- extern f_status_t f_type_fll_ids_adjust(const f_array_length_t length, f_fll_ids_t *ids);
-#endif // _di_f_type_fll_ids_adjust_
+#ifndef _di_f_fll_ids_adjust_
+ extern f_status_t f_fll_ids_adjust(const f_array_length_t length, f_fll_ids_t *ids);
+#endif // _di_f_fll_ids_adjust_
/**
* Append the source ids onto the destination.
*
* Errors (with error bit) from: f_memory_resize().
*/
-#ifndef _di_f_type_fll_ids_append_
- extern f_status_t f_type_fll_ids_append(const f_fll_ids_t source, f_fll_ids_t *destination);
-#endif // _di_f_type_fll_ids_append_
+#ifndef _di_f_fll_ids_append_
+ extern f_status_t f_fll_ids_append(const f_fll_ids_t source, f_fll_ids_t *destination);
+#endif // _di_f_fll_ids_append_
/**
* Resize the string ids array to a smaller size.
*
* Errors (with error bit) from: f_memory_adjust().
*/
-#ifndef _di_f_type_fll_ids_decimate_by_
- extern f_status_t f_type_fll_ids_decimate_by(const f_array_length_t amount, f_fll_ids_t *ids);
-#endif // _di_f_type_fll_ids_decimate_by_
+#ifndef _di_f_fll_ids_decimate_by_
+ extern f_status_t f_fll_ids_decimate_by(const f_array_length_t amount, f_fll_ids_t *ids);
+#endif // _di_f_fll_ids_decimate_by_
/**
* Resize the string ids array to a smaller size.
*
* Errors (with error bit) from: f_memory_resize().
*/
-#ifndef _di_f_type_fll_ids_decrease_by_
- extern f_status_t f_type_fll_ids_decrease_by(const f_array_length_t amount, f_fll_ids_t *ids);
-#endif // _di_f_type_fll_ids_decrease_by_
+#ifndef _di_f_fll_ids_decrease_by_
+ extern f_status_t f_fll_ids_decrease_by(const f_array_length_t amount, f_fll_ids_t *ids);
+#endif // _di_f_fll_ids_decrease_by_
/**
* Increase the size of the string ids array, but only if necesary.
*
* Errors (with error bit) from: f_memory_resize().
*/
-#ifndef _di_f_type_fll_ids_increase_
- extern f_status_t f_type_fll_ids_increase(const uint16_t step, f_fll_ids_t *ids);
-#endif // _di_f_type_fll_ids_increase_
+#ifndef _di_f_fll_ids_increase_
+ extern f_status_t f_fll_ids_increase(const uint16_t step, f_fll_ids_t *ids);
+#endif // _di_f_fll_ids_increase_
/**
* Resize the string ids array to a larger size.
*
* Errors (with error bit) from: f_memory_resize().
*/
-#ifndef _di_f_type_fll_ids_increase_by_
- extern f_status_t f_type_fll_ids_increase_by(const f_array_length_t amount, f_fll_ids_t *ids);
-#endif // _di_f_type_fll_ids_increase_by_
+#ifndef _di_f_fll_ids_increase_by_
+ extern f_status_t f_fll_ids_increase_by(const f_array_length_t amount, f_fll_ids_t *ids);
+#endif // _di_f_fll_ids_increase_by_
/**
* Resize the string ids array.
*
* Errors (with error bit) from: f_memory_resize().
*/
-#ifndef _di_f_type_fll_ids_resize_
- extern f_status_t f_type_fll_ids_resize(const f_array_length_t length, f_fll_ids_t *ids);
-#endif // _di_f_type_fll_ids_resize_
+#ifndef _di_f_fll_ids_resize_
+ extern f_status_t f_fll_ids_resize(const f_array_length_t length, f_fll_ids_t *ids);
+#endif // _di_f_fll_ids_resize_
/**
* Resize the string idss array.
* Errors (with error bit) from: f_memory_adjust().
* Errors (with error bit) from: f_memory_destroy().
*/
-#ifndef _di_f_type_fll_idss_adjust_
- extern f_status_t f_type_fll_idss_adjust(const f_array_length_t length, f_fll_idss_t *idss);
-#endif // _di_f_type_fll_idss_adjust_
+#ifndef _di_f_fll_idss_adjust_
+ extern f_status_t f_fll_idss_adjust(const f_array_length_t length, f_fll_idss_t *idss);
+#endif // _di_f_fll_idss_adjust_
/**
* Append the source idss onto the destination.
*
* Errors (with error bit) from: f_memory_resize().
*/
-#ifndef _di_f_type_fll_idss_append_
- extern f_status_t f_type_fll_idss_append(const f_fll_idss_t source, f_fll_idss_t *destination);
-#endif // _di_f_type_fll_idss_append_
+#ifndef _di_f_fll_idss_append_
+ extern f_status_t f_fll_idss_append(const f_fll_idss_t source, f_fll_idss_t *destination);
+#endif // _di_f_fll_idss_append_
/**
* Resize the string idss array.
* Errors (with error bit) from: f_memory_adjust().
* Errors (with error bit) from: f_memory_destroy().
*/
-#ifndef _di_f_type_fll_idss_adjust_
- extern f_status_t f_type_fll_idss_adjust(const f_array_length_t length, f_fll_idss_t *idss);
-#endif // _di_f_type_fll_idss_adjust_
+#ifndef _di_f_fll_idss_adjust_
+ extern f_status_t f_fll_idss_adjust(const f_array_length_t length, f_fll_idss_t *idss);
+#endif // _di_f_fll_idss_adjust_
/**
* Resize the string idss array to a smaller size.
* Errors (with error bit) from: f_memory_adjust().
* Errors (with error bit) from: f_memory_destroy().
*/
-#ifndef _di_f_type_fll_idss_decimate_by_
- extern f_status_t f_type_fll_idss_decimate_by(const f_array_length_t amount, f_fll_idss_t *idss);
-#endif // _di_f_type_fll_idss_decimate_by_
+#ifndef _di_f_fll_idss_decimate_by_
+ extern f_status_t f_fll_idss_decimate_by(const f_array_length_t amount, f_fll_idss_t *idss);
+#endif // _di_f_fll_idss_decimate_by_
/**
* Resize the string idss array to a smaller size.
* Errors (with error bit) from: f_memory_delete().
* Errors (with error bit) from: f_memory_resize().
*/
-#ifndef _di_f_type_fll_idss_decrease_by_
- extern f_status_t f_type_fll_idss_decrease_by(const f_array_length_t amount, f_fll_idss_t *idss);
-#endif // _di_f_type_fll_idss_decrease_by_
+#ifndef _di_f_fll_idss_decrease_by_
+ extern f_status_t f_fll_idss_decrease_by(const f_array_length_t amount, f_fll_idss_t *idss);
+#endif // _di_f_fll_idss_decrease_by_
/**
* Increase the size of the string idss array, but only if necessary.
*
* Errors (with error bit) from: f_memory_resize().
*/
-#ifndef _di_f_type_fll_idss_increase_
- extern f_status_t f_type_fll_idss_increase(const uint16_t step, f_fll_idss_t *idss);
-#endif // _di_f_type_fll_idss_increase_
+#ifndef _di_f_fll_idss_increase_
+ extern f_status_t f_fll_idss_increase(const uint16_t step, f_fll_idss_t *idss);
+#endif // _di_f_fll_idss_increase_
/**
* Resize the string idss array to a larger size.
*
* Errors (with error bit) from: f_memory_resize().
*/
-#ifndef _di_f_type_fll_idss_increase_by_
- extern f_status_t f_type_fll_idss_increase_by(const f_array_length_t amount, f_fll_idss_t *idss);
-#endif // _di_f_type_fll_idss_increase_by_
+#ifndef _di_f_fll_idss_increase_by_
+ extern f_status_t f_fll_idss_increase_by(const f_array_length_t amount, f_fll_idss_t *idss);
+#endif // _di_f_fll_idss_increase_by_
/**
* Resize the string idss array.
* Errors (with error bit) from: f_memory_delete().
* Errors (with error bit) from: f_memory_resize().
*/
-#ifndef _di_f_type_fll_idss_resize_
- extern f_status_t f_type_fll_idss_resize(const f_array_length_t length, f_fll_idss_t *idss);
-#endif // _di_f_type_fll_idss_resize_
+#ifndef _di_f_fll_idss_resize_
+ extern f_status_t f_fll_idss_resize(const f_array_length_t length, f_fll_idss_t *idss);
+#endif // _di_f_fll_idss_resize_
#ifdef __cplusplus
} // extern "C"
extern "C" {
#endif
-#ifndef _di_f_type_int128s_adjust_
- f_status_t f_type_int128s_adjust(const f_array_length_t length, f_int128s_t *int128s) {
+#ifndef _di_f_int128s_adjust_
+ f_status_t f_int128s_adjust(const f_array_length_t length, f_int128s_t *int128s) {
#ifndef _di_level_0_parameter_checking_
if (!int128s) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
- return private_f_type_int128s_adjust(length, int128s);
+ return private_f_int128s_adjust(length, int128s);
}
-#endif // _di_f_type_int128s_adjust_
+#endif // _di_f_int128s_adjust_
-#ifndef _di_f_type_int128s_append_
- f_status_t f_type_int128s_append(const f_int128s_t source, f_int128s_t *destination) {
+#ifndef _di_f_int128s_append_
+ f_status_t f_int128s_append(const f_int128s_t source, f_int128s_t *destination) {
#ifndef _di_level_0_parameter_checking_
if (!destination) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
if (!source.used) return F_data_not;
- return private_f_type_int128s_append(source, destination);
+ return private_f_int128s_append(source, destination);
}
-#endif // _di_f_type_int128s_append_
+#endif // _di_f_int128s_append_
-#ifndef _di_f_type_int128s_decimate_by_
- f_status_t f_type_int128s_decimate_by(const f_array_length_t amount, f_int128s_t *int128s) {
+#ifndef _di_f_int128s_decimate_by_
+ f_status_t f_int128s_decimate_by(const f_array_length_t amount, f_int128s_t *int128s) {
#ifndef _di_level_0_parameter_checking_
if (!amount) return F_status_set_error(F_parameter);
if (!int128s) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
if (int128s->size - amount > 0) {
- return private_f_type_int128s_adjust(int128s->size - amount, int128s);
+ return private_f_int128s_adjust(int128s->size - amount, int128s);
}
- return private_f_type_int128s_adjust(0, int128s);
+ return private_f_int128s_adjust(0, int128s);
}
-#endif // _di_f_type_int128s_decimate_by_
+#endif // _di_f_int128s_decimate_by_
-#ifndef _di_f_type_int128s_decrease_by_
- f_status_t f_type_int128s_decrease_by(const f_array_length_t amount, f_int128s_t *int128s) {
+#ifndef _di_f_int128s_decrease_by_
+ f_status_t f_int128s_decrease_by(const f_array_length_t amount, f_int128s_t *int128s) {
#ifndef _di_level_0_parameter_checking_
if (!amount) return F_status_set_error(F_parameter);
if (!int128s) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
if (int128s->size - amount > 0) {
- return private_f_type_int128s_resize(int128s->size - amount, int128s);
+ return private_f_int128s_resize(int128s->size - amount, int128s);
}
- return private_f_type_int128s_resize(0, int128s);
+ return private_f_int128s_resize(0, int128s);
}
-#endif // _di_f_type_int128s_decrease_by_
+#endif // _di_f_int128s_decrease_by_
-#ifndef _di_f_type_int128s_increase_
- f_status_t f_type_int128s_increase(const uint16_t step, f_int128s_t *int128s) {
+#ifndef _di_f_int128s_increase_
+ f_status_t f_int128s_increase(const uint16_t step, f_int128s_t *int128s) {
#ifndef _di_level_0_parameter_checking_
if (!step) return F_status_set_error(F_parameter);
if (!int128s) return F_status_set_error(F_parameter);
size = F_array_length_t_size_d;
}
- return private_f_type_int128s_resize(size, int128s);
+ return private_f_int128s_resize(size, int128s);
}
return F_data_not;
}
-#endif // _di_f_type_int128s_increase_
+#endif // _di_f_int128s_increase_
-#ifndef _di_f_type_int128s_increase_by_
- f_status_t f_type_int128s_increase_by(const f_array_length_t amount, f_int128s_t *int128s) {
+#ifndef _di_f_int128s_increase_by_
+ f_status_t f_int128s_increase_by(const f_array_length_t amount, f_int128s_t *int128s) {
#ifndef _di_level_0_parameter_checking_
if (!amount) return F_status_set_error(F_parameter);
if (!int128s) return F_status_set_error(F_parameter);
return F_status_set_error(F_array_too_large);
}
- return private_f_type_int128s_resize(int128s->used + amount, int128s);
+ return private_f_int128s_resize(int128s->used + amount, int128s);
}
return F_data_not;
}
-#endif // _di_f_type_int128s_increase_by_
+#endif // _di_f_int128s_increase_by_
-#ifndef _di_f_type_int128s_resize_
- f_status_t f_type_int128s_resize(const f_array_length_t length, f_int128s_t *int128s) {
+#ifndef _di_f_int128s_resize_
+ f_status_t f_int128s_resize(const f_array_length_t length, f_int128s_t *int128s) {
#ifndef _di_level_0_parameter_checking_
if (!int128s) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
- return private_f_type_int128s_resize(length, int128s);
+ return private_f_int128s_resize(length, int128s);
}
-#endif // _di_f_type_int128s_resize_
+#endif // _di_f_int128s_resize_
-#ifndef _di_f_type_int128ss_adjust_
- f_status_t f_type_int128ss_adjust(const f_array_length_t length, f_int128ss_t *int128ss) {
+#ifndef _di_f_int128ss_adjust_
+ f_status_t f_int128ss_adjust(const f_array_length_t length, f_int128ss_t *int128ss) {
#ifndef _di_level_0_parameter_checking_
if (!int128ss) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
- return private_f_type_int128ss_adjust(length, int128ss);
+ return private_f_int128ss_adjust(length, int128ss);
}
-#endif // _di_f_type_int128ss_adjust_
+#endif // _di_f_int128ss_adjust_
-#ifndef _di_f_type_int128ss_append_
- f_status_t f_type_int128ss_append(const f_int128ss_t source, f_int128ss_t *destination) {
+#ifndef _di_f_int128ss_append_
+ f_status_t f_int128ss_append(const f_int128ss_t source, f_int128ss_t *destination) {
#ifndef _di_level_0_parameter_checking_
if (!destination) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
f_status_t status = F_none;
if (destination->used + source.used > destination->size) {
- status = private_f_type_int128ss_resize(destination->used + source.used, destination);
+ status = private_f_int128ss_resize(destination->used + source.used, destination);
if (F_status_is_error(status)) return status;
}
for (f_array_length_t i = 0; i < source.used; ++i, ++destination->used) {
- status = private_f_type_int128s_append(source.array[i], &destination->array[destination->used]);
+ status = private_f_int128s_append(source.array[i], &destination->array[destination->used]);
if (F_status_is_error(status)) return status;
} // for
return F_none;
}
-#endif // _di_f_type_int128ss_append_
+#endif // _di_f_int128ss_append_
-#ifndef _di_f_type_int128ss_decimate_by_
- f_status_t f_type_int128ss_decimate_by(const f_array_length_t amount, f_int128ss_t *int128ss) {
+#ifndef _di_f_int128ss_decimate_by_
+ f_status_t f_int128ss_decimate_by(const f_array_length_t amount, f_int128ss_t *int128ss) {
#ifndef _di_level_0_parameter_checking_
if (!amount) return F_status_set_error(F_parameter);
if (!int128ss) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
if (int128ss->size - amount > 0) {
- return private_f_type_int128ss_adjust(int128ss->size - amount, int128ss);
+ return private_f_int128ss_adjust(int128ss->size - amount, int128ss);
}
- return private_f_type_int128ss_adjust(0, int128ss);
+ return private_f_int128ss_adjust(0, int128ss);
}
-#endif // _di_f_type_int128ss_decimate_by_
+#endif // _di_f_int128ss_decimate_by_
-#ifndef _di_f_type_int128ss_decrease_by_
- f_status_t f_type_int128ss_decrease_by(const f_array_length_t amount, f_int128ss_t *int128ss) {
+#ifndef _di_f_int128ss_decrease_by_
+ f_status_t f_int128ss_decrease_by(const f_array_length_t amount, f_int128ss_t *int128ss) {
#ifndef _di_level_0_parameter_checking_
if (!amount) return F_status_set_error(F_parameter);
if (!int128ss) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
if (int128ss->size - amount > 0) {
- return private_f_type_int128ss_resize(int128ss->size - amount, int128ss);
+ return private_f_int128ss_resize(int128ss->size - amount, int128ss);
}
- return private_f_type_int128ss_resize(0, int128ss);
+ return private_f_int128ss_resize(0, int128ss);
}
-#endif // _di_f_type_int128ss_decrease_by_
+#endif // _di_f_int128ss_decrease_by_
-#ifndef _di_f_type_int128ss_increase_
- f_status_t f_type_int128ss_increase(const uint16_t step, f_int128ss_t *int128ss) {
+#ifndef _di_f_int128ss_increase_
+ f_status_t f_int128ss_increase(const uint16_t step, f_int128ss_t *int128ss) {
#ifndef _di_level_0_parameter_checking_
if (!step) return F_status_set_error(F_parameter);
if (!int128ss) return F_status_set_error(F_parameter);
size = F_array_length_t_size_d;
}
- return private_f_type_int128ss_resize(size, int128ss);
+ return private_f_int128ss_resize(size, int128ss);
}
return F_data_not;
}
-#endif // _di_f_type_int128ss_increase_
+#endif // _di_f_int128ss_increase_
-#ifndef _di_f_type_int128ss_increase_by_
- f_status_t f_type_int128ss_increase_by(const f_array_length_t amount, f_int128ss_t *int128ss) {
+#ifndef _di_f_int128ss_increase_by_
+ f_status_t f_int128ss_increase_by(const f_array_length_t amount, f_int128ss_t *int128ss) {
#ifndef _di_level_0_parameter_checking_
if (!amount) return F_status_set_error(F_parameter);
if (!int128ss) return F_status_set_error(F_parameter);
return F_status_set_error(F_array_too_large);
}
- return private_f_type_int128ss_resize(int128ss->used + amount, int128ss);
+ return private_f_int128ss_resize(int128ss->used + amount, int128ss);
}
return F_data_not;
}
-#endif // _di_f_type_int128ss_increase_by_
+#endif // _di_f_int128ss_increase_by_
-#ifndef _di_f_type_int128ss_resize_
- f_status_t f_type_int128ss_resize(const f_array_length_t length, f_int128ss_t *int128ss) {
+#ifndef _di_f_int128ss_resize_
+ f_status_t f_int128ss_resize(const f_array_length_t length, f_int128ss_t *int128ss) {
#ifndef _di_level_0_parameter_checking_
if (!int128ss) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
- return private_f_type_int128ss_resize(length, int128ss);
+ return private_f_int128ss_resize(length, int128ss);
}
-#endif // _di_f_type_int128ss_resize_
+#endif // _di_f_int128ss_resize_
-#ifndef _di_f_type_uint128s_adjust_
- f_status_t f_type_uint128s_adjust(const f_array_length_t length, f_uint128s_t *uint128s) {
+#ifndef _di_f_uint128s_adjust_
+ f_status_t f_uint128s_adjust(const f_array_length_t length, f_uint128s_t *uint128s) {
#ifndef _di_level_0_parameter_checking_
if (!uint128s) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
- return private_f_type_uint128s_adjust(length, uint128s);
+ return private_f_uint128s_adjust(length, uint128s);
}
-#endif // _di_f_type_uint128s_adjust_
+#endif // _di_f_uint128s_adjust_
-#ifndef _di_f_type_uint128s_append_
- f_status_t f_type_uint128s_append(const f_uint128s_t source, f_uint128s_t *destination) {
+#ifndef _di_f_uint128s_append_
+ f_status_t f_uint128s_append(const f_uint128s_t source, f_uint128s_t *destination) {
#ifndef _di_level_0_parameter_checking_
if (!destination) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
if (!source.used) return F_data_not;
- return private_f_type_uint128s_append(source, destination);
+ return private_f_uint128s_append(source, destination);
}
-#endif // _di_f_type_uint128s_append_
+#endif // _di_f_uint128s_append_
-#ifndef _di_f_type_uint128s_decimate_by_
- f_status_t f_type_uint128s_decimate_by(const f_array_length_t amount, f_uint128s_t *uint128s) {
+#ifndef _di_f_uint128s_decimate_by_
+ f_status_t f_uint128s_decimate_by(const f_array_length_t amount, f_uint128s_t *uint128s) {
#ifndef _di_level_0_parameter_checking_
if (!amount) return F_status_set_error(F_parameter);
if (!uint128s) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
if (uint128s->size - amount > 0) {
- return private_f_type_uint128s_adjust(uint128s->size - amount, uint128s);
+ return private_f_uint128s_adjust(uint128s->size - amount, uint128s);
}
- return private_f_type_uint128s_adjust(0, uint128s);
+ return private_f_uint128s_adjust(0, uint128s);
}
-#endif // _di_f_type_uint128s_decimate_by_
+#endif // _di_f_uint128s_decimate_by_
-#ifndef _di_f_type_uint128s_decrease_by_
- f_status_t f_type_uint128s_decrease_by(const f_array_length_t amount, f_uint128s_t *uint128s) {
+#ifndef _di_f_uint128s_decrease_by_
+ f_status_t f_uint128s_decrease_by(const f_array_length_t amount, f_uint128s_t *uint128s) {
#ifndef _di_level_0_parameter_checking_
if (!amount) return F_status_set_error(F_parameter);
if (!uint128s) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
if (uint128s->size - amount > 0) {
- return private_f_type_uint128s_resize(uint128s->size - amount, uint128s);
+ return private_f_uint128s_resize(uint128s->size - amount, uint128s);
}
- return private_f_type_uint128s_resize(0, uint128s);
+ return private_f_uint128s_resize(0, uint128s);
}
-#endif // _di_f_type_uint128s_decrease_by_
+#endif // _di_f_uint128s_decrease_by_
-#ifndef _di_f_type_uint128s_increase_
- f_status_t f_type_uint128s_increase(const uint16_t step, f_uint128s_t *uint128s) {
+#ifndef _di_f_uint128s_increase_
+ f_status_t f_uint128s_increase(const uint16_t step, f_uint128s_t *uint128s) {
#ifndef _di_level_0_parameter_checking_
if (!step) return F_status_set_error(F_parameter);
if (!uint128s) return F_status_set_error(F_parameter);
size = F_array_length_t_size_d;
}
- return private_f_type_uint128s_resize(size, uint128s);
+ return private_f_uint128s_resize(size, uint128s);
}
return F_data_not;
}
-#endif // _di_f_type_uint128s_increase_
+#endif // _di_f_uint128s_increase_
-#ifndef _di_f_type_uint128s_increase_by_
- f_status_t f_type_uint128s_increase_by(const f_array_length_t amount, f_uint128s_t *uint128s) {
+#ifndef _di_f_uint128s_increase_by_
+ f_status_t f_uint128s_increase_by(const f_array_length_t amount, f_uint128s_t *uint128s) {
#ifndef _di_level_0_parameter_checking_
if (!amount) return F_status_set_error(F_parameter);
if (!uint128s) return F_status_set_error(F_parameter);
return F_status_set_error(F_array_too_large);
}
- return private_f_type_uint128s_resize(uint128s->used + amount, uint128s);
+ return private_f_uint128s_resize(uint128s->used + amount, uint128s);
}
return F_data_not;
}
-#endif // _di_f_type_uint128s_increase_by_
+#endif // _di_f_uint128s_increase_by_
-#ifndef _di_f_type_uint128s_resize_
- f_status_t f_type_uint128s_resize(const f_array_length_t length, f_uint128s_t *uint128s) {
+#ifndef _di_f_uint128s_resize_
+ f_status_t f_uint128s_resize(const f_array_length_t length, f_uint128s_t *uint128s) {
#ifndef _di_level_0_parameter_checking_
if (!uint128s) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
- return private_f_type_uint128s_resize(length, uint128s);
+ return private_f_uint128s_resize(length, uint128s);
}
-#endif // _di_f_type_uint128s_resize_
+#endif // _di_f_uint128s_resize_
-#ifndef _di_f_type_uint128ss_adjust_
- f_status_t f_type_uint128ss_adjust(const f_array_length_t length, f_uint128ss_t *uint128ss) {
+#ifndef _di_f_uint128ss_adjust_
+ f_status_t f_uint128ss_adjust(const f_array_length_t length, f_uint128ss_t *uint128ss) {
#ifndef _di_level_0_parameter_checking_
if (!uint128ss) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
- return private_f_type_uint128ss_adjust(length, uint128ss);
+ return private_f_uint128ss_adjust(length, uint128ss);
}
-#endif // _di_f_type_uint128ss_adjust_
+#endif // _di_f_uint128ss_adjust_
-#ifndef _di_f_type_uint128ss_append_
- f_status_t f_type_uint128ss_append(const f_uint128ss_t source, f_uint128ss_t *destination) {
+#ifndef _di_f_uint128ss_append_
+ f_status_t f_uint128ss_append(const f_uint128ss_t source, f_uint128ss_t *destination) {
#ifndef _di_level_0_parameter_checking_
if (!destination) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
f_status_t status = F_none;
if (destination->used + source.used > destination->size) {
- status = private_f_type_uint128ss_resize(destination->used + source.used, destination);
+ status = private_f_uint128ss_resize(destination->used + source.used, destination);
if (F_status_is_error(status)) return status;
}
for (f_array_length_t i = 0; i < source.used; ++i, ++destination->used) {
- status = private_f_type_uint128s_append(source.array[i], &destination->array[destination->used]);
+ status = private_f_uint128s_append(source.array[i], &destination->array[destination->used]);
if (F_status_is_error(status)) return status;
} // for
return F_none;
}
-#endif // _di_f_type_uint128ss_append_
+#endif // _di_f_uint128ss_append_
-#ifndef _di_f_type_uint128ss_decimate_by_
- f_status_t f_type_uint128ss_decimate_by(const f_array_length_t amount, f_uint128ss_t *uint128ss) {
+#ifndef _di_f_uint128ss_decimate_by_
+ f_status_t f_uint128ss_decimate_by(const f_array_length_t amount, f_uint128ss_t *uint128ss) {
#ifndef _di_level_0_parameter_checking_
if (!amount) return F_status_set_error(F_parameter);
if (!uint128ss) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
if (uint128ss->size - amount > 0) {
- return private_f_type_uint128ss_adjust(uint128ss->size - amount, uint128ss);
+ return private_f_uint128ss_adjust(uint128ss->size - amount, uint128ss);
}
- return private_f_type_uint128ss_adjust(0, uint128ss);
+ return private_f_uint128ss_adjust(0, uint128ss);
}
-#endif // _di_f_type_uint128ss_decimate_by_
+#endif // _di_f_uint128ss_decimate_by_
-#ifndef _di_f_type_uint128ss_decrease_by_
- f_status_t f_type_uint128ss_decrease_by(const f_array_length_t amount, f_uint128ss_t *uint128ss) {
+#ifndef _di_f_uint128ss_decrease_by_
+ f_status_t f_uint128ss_decrease_by(const f_array_length_t amount, f_uint128ss_t *uint128ss) {
#ifndef _di_level_0_parameter_checking_
if (!amount) return F_status_set_error(F_parameter);
if (!uint128ss) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
if (uint128ss->size - amount > 0) {
- return private_f_type_uint128ss_resize(uint128ss->size - amount, uint128ss);
+ return private_f_uint128ss_resize(uint128ss->size - amount, uint128ss);
}
- return private_f_type_uint128ss_resize(0, uint128ss);
+ return private_f_uint128ss_resize(0, uint128ss);
}
-#endif // _di_f_type_uint128ss_decrease_by_
+#endif // _di_f_uint128ss_decrease_by_
-#ifndef _di_f_type_uint128ss_increase_
- f_status_t f_type_uint128ss_increase(const uint16_t step, f_uint128ss_t *uint128ss) {
+#ifndef _di_f_uint128ss_increase_
+ f_status_t f_uint128ss_increase(const uint16_t step, f_uint128ss_t *uint128ss) {
#ifndef _di_level_0_parameter_checking_
if (!step) return F_status_set_error(F_parameter);
if (!uint128ss) return F_status_set_error(F_parameter);
size = F_array_length_t_size_d;
}
- return private_f_type_uint128ss_resize(size, uint128ss);
+ return private_f_uint128ss_resize(size, uint128ss);
}
return F_data_not;
}
-#endif // _di_f_type_uint128ss_increase_
+#endif // _di_f_uint128ss_increase_
-#ifndef _di_f_type_uint128ss_increase_by_
- f_status_t f_type_uint128ss_increase_by(const f_array_length_t amount, f_uint128ss_t *uint128ss) {
+#ifndef _di_f_uint128ss_increase_by_
+ f_status_t f_uint128ss_increase_by(const f_array_length_t amount, f_uint128ss_t *uint128ss) {
#ifndef _di_level_0_parameter_checking_
if (!amount) return F_status_set_error(F_parameter);
if (!uint128ss) return F_status_set_error(F_parameter);
return F_status_set_error(F_array_too_large);
}
- return private_f_type_uint128ss_resize(uint128ss->used + amount, uint128ss);
+ return private_f_uint128ss_resize(uint128ss->used + amount, uint128ss);
}
return F_data_not;
}
-#endif // _di_f_type_uint128ss_increase_by_
+#endif // _di_f_uint128ss_increase_by_
-#ifndef _di_f_type_uint128ss_resize_
- f_status_t f_type_uint128ss_resize(const f_array_length_t length, f_uint128ss_t *uint128ss) {
+#ifndef _di_f_uint128ss_resize_
+ f_status_t f_uint128ss_resize(const f_array_length_t length, f_uint128ss_t *uint128ss) {
#ifndef _di_level_0_parameter_checking_
if (!uint128ss) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
- return private_f_type_uint128ss_resize(length, uint128ss);
+ return private_f_uint128ss_resize(length, uint128ss);
}
-#endif // _di_f_type_uint128ss_resize_
+#endif // _di_f_uint128ss_resize_
#ifdef __cplusplus
} // extern "C"
*
* Errors (with error bit) from: f_memory_adjust().
*/
-#ifndef _di_f_type_int128s_adjust_
- extern f_status_t f_type_int128s_adjust(const f_array_length_t length, f_int128s_t *int128s);
-#endif // _di_f_type_int128s_adjust_
+#ifndef _di_f_int128s_adjust_
+ extern f_status_t f_int128s_adjust(const f_array_length_t length, f_int128s_t *int128s);
+#endif // _di_f_int128s_adjust_
/**
* Append the source int128s onto the destination.
*
* Errors (with error bit) from: f_memory_resize().
*/
-#ifndef _di_f_type_int128s_append_
- extern f_status_t f_type_int128s_append(const f_int128s_t source, f_int128s_t *destination);
-#endif // _di_f_type_int128s_append_
+#ifndef _di_f_int128s_append_
+ extern f_status_t f_int128s_append(const f_int128s_t source, f_int128s_t *destination);
+#endif // _di_f_int128s_append_
/**
* Resize the int128s array to a smaller size.
*
* Errors (with error bit) from: f_memory_adjust().
*/
-#ifndef _di_f_type_int128s_decimate_by_
- extern f_status_t f_type_int128s_decimate_by(const f_array_length_t amount, f_int128s_t *int128s);
-#endif // _di_f_type_int128s_decimate_by_
+#ifndef _di_f_int128s_decimate_by_
+ extern f_status_t f_int128s_decimate_by(const f_array_length_t amount, f_int128s_t *int128s);
+#endif // _di_f_int128s_decimate_by_
/**
* Resize the int128s array to a smaller size.
*
* Errors (with error bit) from: f_memory_resize().
*/
-#ifndef _di_f_type_int128s_decrease_by_
- extern f_status_t f_type_int128s_decrease_by(const f_array_length_t amount, f_int128s_t *int128s);
-#endif // _di_f_type_int128s_decrease_by_
+#ifndef _di_f_int128s_decrease_by_
+ extern f_status_t f_int128s_decrease_by(const f_array_length_t amount, f_int128s_t *int128s);
+#endif // _di_f_int128s_decrease_by_
/**
* Increase the size of the int128s array, but only if necesary.
*
* Errors (with error bit) from: f_memory_resize().
*/
-#ifndef _di_f_type_int128s_increase_
- extern f_status_t f_type_int128s_increase(const uint16_t step, f_int128s_t *int128s);
-#endif // _di_f_type_int128s_increase_
+#ifndef _di_f_int128s_increase_
+ extern f_status_t f_int128s_increase(const uint16_t step, f_int128s_t *int128s);
+#endif // _di_f_int128s_increase_
/**
* Resize the int128s array to a larger size.
*
* Errors (with error bit) from: f_memory_resize().
*/
-#ifndef _di_f_type_int128s_increase_by_
- extern f_status_t f_type_int128s_increase_by(const f_array_length_t amount, f_int128s_t *int128s);
-#endif // _di_f_type_int128s_increase_by_
+#ifndef _di_f_int128s_increase_by_
+ extern f_status_t f_int128s_increase_by(const f_array_length_t amount, f_int128s_t *int128s);
+#endif // _di_f_int128s_increase_by_
/**
* Resize the int128s array.
*
* Errors (with error bit) from: f_memory_resize().
*/
-#ifndef _di_f_type_int128s_resize_
- extern f_status_t f_type_int128s_resize(const f_array_length_t length, f_int128s_t *int128s);
-#endif // _di_f_type_int128s_resize_
+#ifndef _di_f_int128s_resize_
+ extern f_status_t f_int128s_resize(const f_array_length_t length, f_int128s_t *int128s);
+#endif // _di_f_int128s_resize_
/**
* Resize the int128ss array.
* Errors (with error bit) from: f_memory_adjust().
* Errors (with error bit) from: f_memory_destroy().
*/
-#ifndef _di_f_type_int128ss_adjust_
- extern f_status_t f_type_int128ss_adjust(const f_array_length_t length, f_int128ss_t *int128ss);
-#endif // _di_f_type_int128ss_adjust_
+#ifndef _di_f_int128ss_adjust_
+ extern f_status_t f_int128ss_adjust(const f_array_length_t length, f_int128ss_t *int128ss);
+#endif // _di_f_int128ss_adjust_
/**
* Append the source int128ss onto the destination.
*
* Errors (with error bit) from: f_memory_resize().
*/
-#ifndef _di_f_type_int128ss_append_
- extern f_status_t f_type_int128ss_append(const f_int128ss_t source, f_int128ss_t *destination);
-#endif // _di_f_type_int128ss_append_
+#ifndef _di_f_int128ss_append_
+ extern f_status_t f_int128ss_append(const f_int128ss_t source, f_int128ss_t *destination);
+#endif // _di_f_int128ss_append_
/**
* Resize the int128ss array.
* Errors (with error bit) from: f_memory_adjust().
* Errors (with error bit) from: f_memory_destroy().
*/
-#ifndef _di_f_type_int128ss_adjust_
- extern f_status_t f_type_int128ss_adjust(const f_array_length_t length, f_int128ss_t *int128ss);
-#endif // _di_f_type_int128ss_adjust_
+#ifndef _di_f_int128ss_adjust_
+ extern f_status_t f_int128ss_adjust(const f_array_length_t length, f_int128ss_t *int128ss);
+#endif // _di_f_int128ss_adjust_
/**
* Resize the int128ss array to a smaller size.
* Errors (with error bit) from: f_memory_adjust().
* Errors (with error bit) from: f_memory_destroy().
*/
-#ifndef _di_f_type_int128ss_decimate_by_
- extern f_status_t f_type_int128ss_decimate_by(const f_array_length_t amount, f_int128ss_t *int128ss);
-#endif // _di_f_type_int128ss_decimate_by_
+#ifndef _di_f_int128ss_decimate_by_
+ extern f_status_t f_int128ss_decimate_by(const f_array_length_t amount, f_int128ss_t *int128ss);
+#endif // _di_f_int128ss_decimate_by_
/**
* Resize the int128ss array to a smaller size.
* Errors (with error bit) from: f_memory_delete().
* Errors (with error bit) from: f_memory_resize().
*/
-#ifndef _di_f_type_int128ss_decrease_by_
- extern f_status_t f_type_int128ss_decrease_by(const f_array_length_t amount, f_int128ss_t *int128ss);
-#endif // _di_f_type_int128ss_decrease_by_
+#ifndef _di_f_int128ss_decrease_by_
+ extern f_status_t f_int128ss_decrease_by(const f_array_length_t amount, f_int128ss_t *int128ss);
+#endif // _di_f_int128ss_decrease_by_
/**
* Increase the size of the int128ss array, but only if necessary.
*
* Errors (with error bit) from: f_memory_resize().
*/
-#ifndef _di_f_type_int128ss_increase_
- extern f_status_t f_type_int128ss_increase(const uint16_t step, f_int128ss_t *int128ss);
-#endif // _di_f_type_int128ss_increase_
+#ifndef _di_f_int128ss_increase_
+ extern f_status_t f_int128ss_increase(const uint16_t step, f_int128ss_t *int128ss);
+#endif // _di_f_int128ss_increase_
/**
* Resize the int128ss array to a larger size.
*
* Errors (with error bit) from: f_memory_resize().
*/
-#ifndef _di_f_type_int128ss_increase_by_
- extern f_status_t f_type_int128ss_increase_by(const f_array_length_t amount, f_int128ss_t *int128ss);
-#endif // _di_f_type_int128ss_increase_by_
+#ifndef _di_f_int128ss_increase_by_
+ extern f_status_t f_int128ss_increase_by(const f_array_length_t amount, f_int128ss_t *int128ss);
+#endif // _di_f_int128ss_increase_by_
/**
* Resize the int128ss array.
* Errors (with error bit) from: f_memory_delete().
* Errors (with error bit) from: f_memory_resize().
*/
-#ifndef _di_f_type_int128ss_resize_
- extern f_status_t f_type_int128ss_resize(const f_array_length_t length, f_int128ss_t *int128ss);
-#endif // _di_f_type_int128ss_resize_
+#ifndef _di_f_int128ss_resize_
+ extern f_status_t f_int128ss_resize(const f_array_length_t length, f_int128ss_t *int128ss);
+#endif // _di_f_int128ss_resize_
/**
* Resize the string uint128s array.
*
* Errors (with error bit) from: f_memory_adjust().
*/
-#ifndef _di_f_type_uint128s_adjust_
- extern f_status_t f_type_uint128s_adjust(const f_array_length_t length, f_uint128s_t *uint128s);
-#endif // _di_f_type_uint128s_adjust_
+#ifndef _di_f_uint128s_adjust_
+ extern f_status_t f_uint128s_adjust(const f_array_length_t length, f_uint128s_t *uint128s);
+#endif // _di_f_uint128s_adjust_
/**
* Append the source uint128s onto the destination.
*
* Errors (with error bit) from: f_memory_resize().
*/
-#ifndef _di_f_type_uint128s_append_
- extern f_status_t f_type_uint128s_append(const f_uint128s_t source, f_uint128s_t *destination);
-#endif // _di_f_type_uint128s_append_
+#ifndef _di_f_uint128s_append_
+ extern f_status_t f_uint128s_append(const f_uint128s_t source, f_uint128s_t *destination);
+#endif // _di_f_uint128s_append_
/**
* Resize the string uint128s array to a smaller size.
*
* Errors (with error bit) from: f_memory_adjust().
*/
-#ifndef _di_f_type_uint128s_decimate_by_
- extern f_status_t f_type_uint128s_decimate_by(const f_array_length_t amount, f_uint128s_t *uint128s);
-#endif // _di_f_type_uint128s_decimate_by_
+#ifndef _di_f_uint128s_decimate_by_
+ extern f_status_t f_uint128s_decimate_by(const f_array_length_t amount, f_uint128s_t *uint128s);
+#endif // _di_f_uint128s_decimate_by_
/**
* Resize the string uint128s array to a smaller size.
*
* Errors (with error bit) from: f_memory_resize().
*/
-#ifndef _di_f_type_uint128s_decrease_by_
- extern f_status_t f_type_uint128s_decrease_by(const f_array_length_t amount, f_uint128s_t *uint128s);
-#endif // _di_f_type_uint128s_decrease_by_
+#ifndef _di_f_uint128s_decrease_by_
+ extern f_status_t f_uint128s_decrease_by(const f_array_length_t amount, f_uint128s_t *uint128s);
+#endif // _di_f_uint128s_decrease_by_
/**
* Increase the size of the string uint128s array, but only if necesary.
*
* Errors (with error bit) from: f_memory_resize().
*/
-#ifndef _di_f_type_uint128s_increase_
- extern f_status_t f_type_uint128s_increase(const uint16_t step, f_uint128s_t *uint128s);
-#endif // _di_f_type_uint128s_increase_
+#ifndef _di_f_uint128s_increase_
+ extern f_status_t f_uint128s_increase(const uint16_t step, f_uint128s_t *uint128s);
+#endif // _di_f_uint128s_increase_
/**
* Resize the string uint128s array to a larger size.
*
* Errors (with error bit) from: f_memory_resize().
*/
-#ifndef _di_f_type_uint128s_increase_by_
- extern f_status_t f_type_uint128s_increase_by(const f_array_length_t amount, f_uint128s_t *uint128s);
-#endif // _di_f_type_uint128s_increase_by_
+#ifndef _di_f_uint128s_increase_by_
+ extern f_status_t f_uint128s_increase_by(const f_array_length_t amount, f_uint128s_t *uint128s);
+#endif // _di_f_uint128s_increase_by_
/**
* Resize the string uint128s array.
*
* Errors (with error bit) from: f_memory_resize().
*/
-#ifndef _di_f_type_uint128s_resize_
- extern f_status_t f_type_uint128s_resize(const f_array_length_t length, f_uint128s_t *uint128s);
-#endif // _di_f_type_uint128s_resize_
+#ifndef _di_f_uint128s_resize_
+ extern f_status_t f_uint128s_resize(const f_array_length_t length, f_uint128s_t *uint128s);
+#endif // _di_f_uint128s_resize_
/**
* Resize the string uint128ss array.
* Errors (with error bit) from: f_memory_adjust().
* Errors (with error bit) from: f_memory_destroy().
*/
-#ifndef _di_f_type_uint128ss_adjust_
- extern f_status_t f_type_uint128ss_adjust(const f_array_length_t length, f_uint128ss_t *uint128ss);
-#endif // _di_f_type_uint128ss_adjust_
+#ifndef _di_f_uint128ss_adjust_
+ extern f_status_t f_uint128ss_adjust(const f_array_length_t length, f_uint128ss_t *uint128ss);
+#endif // _di_f_uint128ss_adjust_
/**
* Append the source uint128ss onto the destination.
*
* Errors (with error bit) from: f_memory_resize().
*/
-#ifndef _di_f_type_uint128ss_append_
- extern f_status_t f_type_uint128ss_append(const f_uint128ss_t source, f_uint128ss_t *destination);
-#endif // _di_f_type_uint128ss_append_
+#ifndef _di_f_uint128ss_append_
+ extern f_status_t f_uint128ss_append(const f_uint128ss_t source, f_uint128ss_t *destination);
+#endif // _di_f_uint128ss_append_
/**
* Resize the string uint128ss array.
* Errors (with error bit) from: f_memory_adjust().
* Errors (with error bit) from: f_memory_destroy().
*/
-#ifndef _di_f_type_uint128ss_adjust_
- extern f_status_t f_type_uint128ss_adjust(const f_array_length_t length, f_uint128ss_t *uint128ss);
-#endif // _di_f_type_uint128ss_adjust_
+#ifndef _di_f_uint128ss_adjust_
+ extern f_status_t f_uint128ss_adjust(const f_array_length_t length, f_uint128ss_t *uint128ss);
+#endif // _di_f_uint128ss_adjust_
/**
* Resize the string uint128ss array to a smaller size.
* Errors (with error bit) from: f_memory_adjust().
* Errors (with error bit) from: f_memory_destroy().
*/
-#ifndef _di_f_type_uint128ss_decimate_by_
- extern f_status_t f_type_uint128ss_decimate_by(const f_array_length_t amount, f_uint128ss_t *uint128ss);
-#endif // _di_f_type_uint128ss_decimate_by_
+#ifndef _di_f_uint128ss_decimate_by_
+ extern f_status_t f_uint128ss_decimate_by(const f_array_length_t amount, f_uint128ss_t *uint128ss);
+#endif // _di_f_uint128ss_decimate_by_
/**
* Resize the string uint128ss array to a smaller size.
* Errors (with error bit) from: f_memory_delete().
* Errors (with error bit) from: f_memory_resize().
*/
-#ifndef _di_f_type_uint128ss_decrease_by_
- extern f_status_t f_type_uint128ss_decrease_by(const f_array_length_t amount, f_uint128ss_t *uint128ss);
-#endif // _di_f_type_uint128ss_decrease_by_
+#ifndef _di_f_uint128ss_decrease_by_
+ extern f_status_t f_uint128ss_decrease_by(const f_array_length_t amount, f_uint128ss_t *uint128ss);
+#endif // _di_f_uint128ss_decrease_by_
/**
* Increase the size of the string uint128ss array, but only if necessary.
*
* Errors (with error bit) from: f_memory_resize().
*/
-#ifndef _di_f_type_uint128ss_increase_
- extern f_status_t f_type_uint128ss_increase(const uint16_t step, f_uint128ss_t *uint128ss);
-#endif // _di_f_type_uint128ss_increase_
+#ifndef _di_f_uint128ss_increase_
+ extern f_status_t f_uint128ss_increase(const uint16_t step, f_uint128ss_t *uint128ss);
+#endif // _di_f_uint128ss_increase_
/**
* Resize the string uint128ss array to a larger size.
*
* Errors (with error bit) from: f_memory_resize().
*/
-#ifndef _di_f_type_uint128ss_increase_by_
- extern f_status_t f_type_uint128ss_increase_by(const f_array_length_t amount, f_uint128ss_t *uint128ss);
-#endif // _di_f_type_uint128ss_increase_by_
+#ifndef _di_f_uint128ss_increase_by_
+ extern f_status_t f_uint128ss_increase_by(const f_array_length_t amount, f_uint128ss_t *uint128ss);
+#endif // _di_f_uint128ss_increase_by_
/**
* Resize the string uint128ss array.
* Errors (with error bit) from: f_memory_delete().
* Errors (with error bit) from: f_memory_resize().
*/
-#ifndef _di_f_type_uint128ss_resize_
- extern f_status_t f_type_uint128ss_resize(const f_array_length_t length, f_uint128ss_t *uint128ss);
-#endif // _di_f_type_uint128ss_resize_
+#ifndef _di_f_uint128ss_resize_
+ extern f_status_t f_uint128ss_resize(const f_array_length_t length, f_uint128ss_t *uint128ss);
+#endif // _di_f_uint128ss_resize_
#ifdef __cplusplus
} // extern "C"
extern "C" {
#endif
-#ifndef _di_f_type_int16s_adjust_
- f_status_t f_type_int16s_adjust(const f_array_length_t length, f_int16s_t *int16s) {
+#ifndef _di_f_int16s_adjust_
+ f_status_t f_int16s_adjust(const f_array_length_t length, f_int16s_t *int16s) {
#ifndef _di_level_0_parameter_checking_
if (!int16s) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
- return private_f_type_int16s_adjust(length, int16s);
+ return private_f_int16s_adjust(length, int16s);
}
-#endif // _di_f_type_int16s_adjust_
+#endif // _di_f_int16s_adjust_
-#ifndef _di_f_type_int16s_append_
- f_status_t f_type_int16s_append(const f_int16s_t source, f_int16s_t *destination) {
+#ifndef _di_f_int16s_append_
+ f_status_t f_int16s_append(const f_int16s_t source, f_int16s_t *destination) {
#ifndef _di_level_0_parameter_checking_
if (!destination) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
if (!source.used) return F_data_not;
- return private_f_type_int16s_append(source, destination);
+ return private_f_int16s_append(source, destination);
}
-#endif // _di_f_type_int16s_append_
+#endif // _di_f_int16s_append_
-#ifndef _di_f_type_int16s_decimate_by_
- f_status_t f_type_int16s_decimate_by(const f_array_length_t amount, f_int16s_t *int16s) {
+#ifndef _di_f_int16s_decimate_by_
+ f_status_t f_int16s_decimate_by(const f_array_length_t amount, f_int16s_t *int16s) {
#ifndef _di_level_0_parameter_checking_
if (!amount) return F_status_set_error(F_parameter);
if (!int16s) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
if (int16s->size - amount > 0) {
- return private_f_type_int16s_adjust(int16s->size - amount, int16s);
+ return private_f_int16s_adjust(int16s->size - amount, int16s);
}
- return private_f_type_int16s_adjust(0, int16s);
+ return private_f_int16s_adjust(0, int16s);
}
-#endif // _di_f_type_int16s_decimate_by_
+#endif // _di_f_int16s_decimate_by_
-#ifndef _di_f_type_int16s_decrease_by_
- f_status_t f_type_int16s_decrease_by(const f_array_length_t amount, f_int16s_t *int16s) {
+#ifndef _di_f_int16s_decrease_by_
+ f_status_t f_int16s_decrease_by(const f_array_length_t amount, f_int16s_t *int16s) {
#ifndef _di_level_0_parameter_checking_
if (!amount) return F_status_set_error(F_parameter);
if (!int16s) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
if (int16s->size - amount > 0) {
- return private_f_type_int16s_resize(int16s->size - amount, int16s);
+ return private_f_int16s_resize(int16s->size - amount, int16s);
}
- return private_f_type_int16s_resize(0, int16s);
+ return private_f_int16s_resize(0, int16s);
}
-#endif // _di_f_type_int16s_decrease_by_
+#endif // _di_f_int16s_decrease_by_
-#ifndef _di_f_type_int16s_increase_
- f_status_t f_type_int16s_increase(const uint16_t step, f_int16s_t *int16s) {
+#ifndef _di_f_int16s_increase_
+ f_status_t f_int16s_increase(const uint16_t step, f_int16s_t *int16s) {
#ifndef _di_level_0_parameter_checking_
if (!step) return F_status_set_error(F_parameter);
if (!int16s) return F_status_set_error(F_parameter);
size = F_array_length_t_size_d;
}
- return private_f_type_int16s_resize(size, int16s);
+ return private_f_int16s_resize(size, int16s);
}
return F_data_not;
}
-#endif // _di_f_type_int16s_increase_
+#endif // _di_f_int16s_increase_
-#ifndef _di_f_type_int16s_increase_by_
- f_status_t f_type_int16s_increase_by(const f_array_length_t amount, f_int16s_t *int16s) {
+#ifndef _di_f_int16s_increase_by_
+ f_status_t f_int16s_increase_by(const f_array_length_t amount, f_int16s_t *int16s) {
#ifndef _di_level_0_parameter_checking_
if (!amount) return F_status_set_error(F_parameter);
if (!int16s) return F_status_set_error(F_parameter);
return F_status_set_error(F_array_too_large);
}
- return private_f_type_int16s_resize(int16s->used + amount, int16s);
+ return private_f_int16s_resize(int16s->used + amount, int16s);
}
return F_data_not;
}
-#endif // _di_f_type_int16s_increase_by_
+#endif // _di_f_int16s_increase_by_
-#ifndef _di_f_type_int16s_resize_
- f_status_t f_type_int16s_resize(const f_array_length_t length, f_int16s_t *int16s) {
+#ifndef _di_f_int16s_resize_
+ f_status_t f_int16s_resize(const f_array_length_t length, f_int16s_t *int16s) {
#ifndef _di_level_0_parameter_checking_
if (!int16s) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
- return private_f_type_int16s_resize(length, int16s);
+ return private_f_int16s_resize(length, int16s);
}
-#endif // _di_f_type_int16s_resize_
+#endif // _di_f_int16s_resize_
-#ifndef _di_f_type_int16ss_adjust_
- f_status_t f_type_int16ss_adjust(const f_array_length_t length, f_int16ss_t *int16ss) {
+#ifndef _di_f_int16ss_adjust_
+ f_status_t f_int16ss_adjust(const f_array_length_t length, f_int16ss_t *int16ss) {
#ifndef _di_level_0_parameter_checking_
if (!int16ss) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
- return private_f_type_int16ss_adjust(length, int16ss);
+ return private_f_int16ss_adjust(length, int16ss);
}
-#endif // _di_f_type_int16ss_adjust_
+#endif // _di_f_int16ss_adjust_
-#ifndef _di_f_type_int16ss_append_
- f_status_t f_type_int16ss_append(const f_int16ss_t source, f_int16ss_t *destination) {
+#ifndef _di_f_int16ss_append_
+ f_status_t f_int16ss_append(const f_int16ss_t source, f_int16ss_t *destination) {
#ifndef _di_level_0_parameter_checking_
if (!destination) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
f_status_t status = F_none;
if (destination->used + source.used > destination->size) {
- status = private_f_type_int16ss_resize(destination->used + source.used, destination);
+ status = private_f_int16ss_resize(destination->used + source.used, destination);
if (F_status_is_error(status)) return status;
}
for (f_array_length_t i = 0; i < source.used; ++i, ++destination->used) {
- status = private_f_type_int16s_append(source.array[i], &destination->array[destination->used]);
+ status = private_f_int16s_append(source.array[i], &destination->array[destination->used]);
if (F_status_is_error(status)) return status;
} // for
return F_none;
}
-#endif // _di_f_type_int16ss_append_
+#endif // _di_f_int16ss_append_
-#ifndef _di_f_type_int16ss_decimate_by_
- f_status_t f_type_int16ss_decimate_by(const f_array_length_t amount, f_int16ss_t *int16ss) {
+#ifndef _di_f_int16ss_decimate_by_
+ f_status_t f_int16ss_decimate_by(const f_array_length_t amount, f_int16ss_t *int16ss) {
#ifndef _di_level_0_parameter_checking_
if (!amount) return F_status_set_error(F_parameter);
if (!int16ss) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
if (int16ss->size - amount > 0) {
- return private_f_type_int16ss_adjust(int16ss->size - amount, int16ss);
+ return private_f_int16ss_adjust(int16ss->size - amount, int16ss);
}
- return private_f_type_int16ss_adjust(0, int16ss);
+ return private_f_int16ss_adjust(0, int16ss);
}
-#endif // _di_f_type_int16ss_decimate_by_
+#endif // _di_f_int16ss_decimate_by_
-#ifndef _di_f_type_int16ss_decrease_by_
- f_status_t f_type_int16ss_decrease_by(const f_array_length_t amount, f_int16ss_t *int16ss) {
+#ifndef _di_f_int16ss_decrease_by_
+ f_status_t f_int16ss_decrease_by(const f_array_length_t amount, f_int16ss_t *int16ss) {
#ifndef _di_level_0_parameter_checking_
if (!amount) return F_status_set_error(F_parameter);
if (!int16ss) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
if (int16ss->size - amount > 0) {
- return private_f_type_int16ss_resize(int16ss->size - amount, int16ss);
+ return private_f_int16ss_resize(int16ss->size - amount, int16ss);
}
- return private_f_type_int16ss_resize(0, int16ss);
+ return private_f_int16ss_resize(0, int16ss);
}
-#endif // _di_f_type_int16ss_decrease_by_
+#endif // _di_f_int16ss_decrease_by_
-#ifndef _di_f_type_int16ss_increase_
- f_status_t f_type_int16ss_increase(const uint16_t step, f_int16ss_t *int16ss) {
+#ifndef _di_f_int16ss_increase_
+ f_status_t f_int16ss_increase(const uint16_t step, f_int16ss_t *int16ss) {
#ifndef _di_level_0_parameter_checking_
if (!step) return F_status_set_error(F_parameter);
if (!int16ss) return F_status_set_error(F_parameter);
size = F_array_length_t_size_d;
}
- return private_f_type_int16ss_resize(size, int16ss);
+ return private_f_int16ss_resize(size, int16ss);
}
return F_data_not;
}
-#endif // _di_f_type_int16ss_increase_
+#endif // _di_f_int16ss_increase_
-#ifndef _di_f_type_int16ss_increase_by_
- f_status_t f_type_int16ss_increase_by(const f_array_length_t amount, f_int16ss_t *int16ss) {
+#ifndef _di_f_int16ss_increase_by_
+ f_status_t f_int16ss_increase_by(const f_array_length_t amount, f_int16ss_t *int16ss) {
#ifndef _di_level_0_parameter_checking_
if (!amount) return F_status_set_error(F_parameter);
if (!int16ss) return F_status_set_error(F_parameter);
return F_status_set_error(F_array_too_large);
}
- return private_f_type_int16ss_resize(int16ss->used + amount, int16ss);
+ return private_f_int16ss_resize(int16ss->used + amount, int16ss);
}
return F_data_not;
}
-#endif // _di_f_type_int16ss_increase_by_
+#endif // _di_f_int16ss_increase_by_
-#ifndef _di_f_type_int16ss_resize_
- f_status_t f_type_int16ss_resize(const f_array_length_t length, f_int16ss_t *int16ss) {
+#ifndef _di_f_int16ss_resize_
+ f_status_t f_int16ss_resize(const f_array_length_t length, f_int16ss_t *int16ss) {
#ifndef _di_level_0_parameter_checking_
if (!int16ss) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
- return private_f_type_int16ss_resize(length, int16ss);
+ return private_f_int16ss_resize(length, int16ss);
}
-#endif // _di_f_type_int16ss_resize_
+#endif // _di_f_int16ss_resize_
-#ifndef _di_f_type_uint16s_adjust_
- f_status_t f_type_uint16s_adjust(const f_array_length_t length, f_uint16s_t *uint16s) {
+#ifndef _di_f_uint16s_adjust_
+ f_status_t f_uint16s_adjust(const f_array_length_t length, f_uint16s_t *uint16s) {
#ifndef _di_level_0_parameter_checking_
if (!uint16s) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
- return private_f_type_uint16s_adjust(length, uint16s);
+ return private_f_uint16s_adjust(length, uint16s);
}
-#endif // _di_f_type_uint16s_adjust_
+#endif // _di_f_uint16s_adjust_
-#ifndef _di_f_type_uint16s_append_
- f_status_t f_type_uint16s_append(const f_uint16s_t source, f_uint16s_t *destination) {
+#ifndef _di_f_uint16s_append_
+ f_status_t f_uint16s_append(const f_uint16s_t source, f_uint16s_t *destination) {
#ifndef _di_level_0_parameter_checking_
if (!destination) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
if (!source.used) return F_data_not;
- return private_f_type_uint16s_append(source, destination);
+ return private_f_uint16s_append(source, destination);
}
-#endif // _di_f_type_uint16s_append_
+#endif // _di_f_uint16s_append_
-#ifndef _di_f_type_uint16s_decimate_by_
- f_status_t f_type_uint16s_decimate_by(const f_array_length_t amount, f_uint16s_t *uint16s) {
+#ifndef _di_f_uint16s_decimate_by_
+ f_status_t f_uint16s_decimate_by(const f_array_length_t amount, f_uint16s_t *uint16s) {
#ifndef _di_level_0_parameter_checking_
if (!amount) return F_status_set_error(F_parameter);
if (!uint16s) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
if (uint16s->size - amount > 0) {
- return private_f_type_uint16s_adjust(uint16s->size - amount, uint16s);
+ return private_f_uint16s_adjust(uint16s->size - amount, uint16s);
}
- return private_f_type_uint16s_adjust(0, uint16s);
+ return private_f_uint16s_adjust(0, uint16s);
}
-#endif // _di_f_type_uint16s_decimate_by_
+#endif // _di_f_uint16s_decimate_by_
-#ifndef _di_f_type_uint16s_decrease_by_
- f_status_t f_type_uint16s_decrease_by(const f_array_length_t amount, f_uint16s_t *uint16s) {
+#ifndef _di_f_uint16s_decrease_by_
+ f_status_t f_uint16s_decrease_by(const f_array_length_t amount, f_uint16s_t *uint16s) {
#ifndef _di_level_0_parameter_checking_
if (!amount) return F_status_set_error(F_parameter);
if (!uint16s) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
if (uint16s->size - amount > 0) {
- return private_f_type_uint16s_resize(uint16s->size - amount, uint16s);
+ return private_f_uint16s_resize(uint16s->size - amount, uint16s);
}
- return private_f_type_uint16s_resize(0, uint16s);
+ return private_f_uint16s_resize(0, uint16s);
}
-#endif // _di_f_type_uint16s_decrease_by_
+#endif // _di_f_uint16s_decrease_by_
-#ifndef _di_f_type_uint16s_increase_
- f_status_t f_type_uint16s_increase(const uint16_t step, f_uint16s_t *uint16s) {
+#ifndef _di_f_uint16s_increase_
+ f_status_t f_uint16s_increase(const uint16_t step, f_uint16s_t *uint16s) {
#ifndef _di_level_0_parameter_checking_
if (!step) return F_status_set_error(F_parameter);
if (!uint16s) return F_status_set_error(F_parameter);
size = F_array_length_t_size_d;
}
- return private_f_type_uint16s_resize(size, uint16s);
+ return private_f_uint16s_resize(size, uint16s);
}
return F_data_not;
}
-#endif // _di_f_type_uint16s_increase_
+#endif // _di_f_uint16s_increase_
-#ifndef _di_f_type_uint16s_increase_by_
- f_status_t f_type_uint16s_increase_by(const f_array_length_t amount, f_uint16s_t *uint16s) {
+#ifndef _di_f_uint16s_increase_by_
+ f_status_t f_uint16s_increase_by(const f_array_length_t amount, f_uint16s_t *uint16s) {
#ifndef _di_level_0_parameter_checking_
if (!amount) return F_status_set_error(F_parameter);
if (!uint16s) return F_status_set_error(F_parameter);
return F_status_set_error(F_array_too_large);
}
- return private_f_type_uint16s_resize(uint16s->used + amount, uint16s);
+ return private_f_uint16s_resize(uint16s->used + amount, uint16s);
}
return F_data_not;
}
-#endif // _di_f_type_uint16s_increase_by_
+#endif // _di_f_uint16s_increase_by_
-#ifndef _di_f_type_uint16s_resize_
- f_status_t f_type_uint16s_resize(const f_array_length_t length, f_uint16s_t *uint16s) {
+#ifndef _di_f_uint16s_resize_
+ f_status_t f_uint16s_resize(const f_array_length_t length, f_uint16s_t *uint16s) {
#ifndef _di_level_0_parameter_checking_
if (!uint16s) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
- return private_f_type_uint16s_resize(length, uint16s);
+ return private_f_uint16s_resize(length, uint16s);
}
-#endif // _di_f_type_uint16s_resize_
+#endif // _di_f_uint16s_resize_
-#ifndef _di_f_type_uint16ss_adjust_
- f_status_t f_type_uint16ss_adjust(const f_array_length_t length, f_uint16ss_t *uint16ss) {
+#ifndef _di_f_uint16ss_adjust_
+ f_status_t f_uint16ss_adjust(const f_array_length_t length, f_uint16ss_t *uint16ss) {
#ifndef _di_level_0_parameter_checking_
if (!uint16ss) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
- return private_f_type_uint16ss_adjust(length, uint16ss);
+ return private_f_uint16ss_adjust(length, uint16ss);
}
-#endif // _di_f_type_uint16ss_adjust_
+#endif // _di_f_uint16ss_adjust_
-#ifndef _di_f_type_uint16ss_append_
- f_status_t f_type_uint16ss_append(const f_uint16ss_t source, f_uint16ss_t *destination) {
+#ifndef _di_f_uint16ss_append_
+ f_status_t f_uint16ss_append(const f_uint16ss_t source, f_uint16ss_t *destination) {
#ifndef _di_level_0_parameter_checking_
if (!destination) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
f_status_t status = F_none;
if (destination->used + source.used > destination->size) {
- status = private_f_type_uint16ss_resize(destination->used + source.used, destination);
+ status = private_f_uint16ss_resize(destination->used + source.used, destination);
if (F_status_is_error(status)) return status;
}
for (f_array_length_t i = 0; i < source.used; ++i, ++destination->used) {
- status = private_f_type_uint16s_append(source.array[i], &destination->array[destination->used]);
+ status = private_f_uint16s_append(source.array[i], &destination->array[destination->used]);
if (F_status_is_error(status)) return status;
} // for
return F_none;
}
-#endif // _di_f_type_uint16ss_append_
+#endif // _di_f_uint16ss_append_
-#ifndef _di_f_type_uint16ss_decimate_by_
- f_status_t f_type_uint16ss_decimate_by(const f_array_length_t amount, f_uint16ss_t *uint16ss) {
+#ifndef _di_f_uint16ss_decimate_by_
+ f_status_t f_uint16ss_decimate_by(const f_array_length_t amount, f_uint16ss_t *uint16ss) {
#ifndef _di_level_0_parameter_checking_
if (!amount) return F_status_set_error(F_parameter);
if (!uint16ss) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
if (uint16ss->size - amount > 0) {
- return private_f_type_uint16ss_adjust(uint16ss->size - amount, uint16ss);
+ return private_f_uint16ss_adjust(uint16ss->size - amount, uint16ss);
}
- return private_f_type_uint16ss_adjust(0, uint16ss);
+ return private_f_uint16ss_adjust(0, uint16ss);
}
-#endif // _di_f_type_uint16ss_decimate_by_
+#endif // _di_f_uint16ss_decimate_by_
-#ifndef _di_f_type_uint16ss_decrease_by_
- f_status_t f_type_uint16ss_decrease_by(const f_array_length_t amount, f_uint16ss_t *uint16ss) {
+#ifndef _di_f_uint16ss_decrease_by_
+ f_status_t f_uint16ss_decrease_by(const f_array_length_t amount, f_uint16ss_t *uint16ss) {
#ifndef _di_level_0_parameter_checking_
if (!amount) return F_status_set_error(F_parameter);
if (!uint16ss) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
if (uint16ss->size - amount > 0) {
- return private_f_type_uint16ss_resize(uint16ss->size - amount, uint16ss);
+ return private_f_uint16ss_resize(uint16ss->size - amount, uint16ss);
}
- return private_f_type_uint16ss_resize(0, uint16ss);
+ return private_f_uint16ss_resize(0, uint16ss);
}
-#endif // _di_f_type_uint16ss_decrease_by_
+#endif // _di_f_uint16ss_decrease_by_
-#ifndef _di_f_type_uint16ss_increase_
- f_status_t f_type_uint16ss_increase(const uint16_t step, f_uint16ss_t *uint16ss) {
+#ifndef _di_f_uint16ss_increase_
+ f_status_t f_uint16ss_increase(const uint16_t step, f_uint16ss_t *uint16ss) {
#ifndef _di_level_0_parameter_checking_
if (!step) return F_status_set_error(F_parameter);
if (!uint16ss) return F_status_set_error(F_parameter);
size = F_array_length_t_size_d;
}
- return private_f_type_uint16ss_resize(size, uint16ss);
+ return private_f_uint16ss_resize(size, uint16ss);
}
return F_data_not;
}
-#endif // _di_f_type_uint16ss_increase_
+#endif // _di_f_uint16ss_increase_
-#ifndef _di_f_type_uint16ss_increase_by_
- f_status_t f_type_uint16ss_increase_by(const f_array_length_t amount, f_uint16ss_t *uint16ss) {
+#ifndef _di_f_uint16ss_increase_by_
+ f_status_t f_uint16ss_increase_by(const f_array_length_t amount, f_uint16ss_t *uint16ss) {
#ifndef _di_level_0_parameter_checking_
if (!amount) return F_status_set_error(F_parameter);
if (!uint16ss) return F_status_set_error(F_parameter);
return F_status_set_error(F_array_too_large);
}
- return private_f_type_uint16ss_resize(uint16ss->used + amount, uint16ss);
+ return private_f_uint16ss_resize(uint16ss->used + amount, uint16ss);
}
return F_data_not;
}
-#endif // _di_f_type_uint16ss_increase_by_
+#endif // _di_f_uint16ss_increase_by_
-#ifndef _di_f_type_uint16ss_resize_
- f_status_t f_type_uint16ss_resize(const f_array_length_t length, f_uint16ss_t *uint16ss) {
+#ifndef _di_f_uint16ss_resize_
+ f_status_t f_uint16ss_resize(const f_array_length_t length, f_uint16ss_t *uint16ss) {
#ifndef _di_level_0_parameter_checking_
if (!uint16ss) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
- return private_f_type_uint16ss_resize(length, uint16ss);
+ return private_f_uint16ss_resize(length, uint16ss);
}
-#endif // _di_f_type_uint16ss_resize_
+#endif // _di_f_uint16ss_resize_
#ifdef __cplusplus
} // extern "C"
*
* Errors (with error bit) from: f_memory_adjust().
*/
-#ifndef _di_f_type_int16s_adjust_
- extern f_status_t f_type_int16s_adjust(const f_array_length_t length, f_int16s_t *int16s);
-#endif // _di_f_type_int16s_adjust_
+#ifndef _di_f_int16s_adjust_
+ extern f_status_t f_int16s_adjust(const f_array_length_t length, f_int16s_t *int16s);
+#endif // _di_f_int16s_adjust_
/**
* Append the source int16s onto the destination.
*
* Errors (with error bit) from: f_memory_resize().
*/
-#ifndef _di_f_type_int16s_append_
- extern f_status_t f_type_int16s_append(const f_int16s_t source, f_int16s_t *destination);
-#endif // _di_f_type_int16s_append_
+#ifndef _di_f_int16s_append_
+ extern f_status_t f_int16s_append(const f_int16s_t source, f_int16s_t *destination);
+#endif // _di_f_int16s_append_
/**
* Resize the int16s array to a smaller size.
*
* Errors (with error bit) from: f_memory_adjust().
*/
-#ifndef _di_f_type_int16s_decimate_by_
- extern f_status_t f_type_int16s_decimate_by(const f_array_length_t amount, f_int16s_t *int16s);
-#endif // _di_f_type_int16s_decimate_by_
+#ifndef _di_f_int16s_decimate_by_
+ extern f_status_t f_int16s_decimate_by(const f_array_length_t amount, f_int16s_t *int16s);
+#endif // _di_f_int16s_decimate_by_
/**
* Resize the int16s array to a smaller size.
*
* Errors (with error bit) from: f_memory_resize().
*/
-#ifndef _di_f_type_int16s_decrease_by_
- extern f_status_t f_type_int16s_decrease_by(const f_array_length_t amount, f_int16s_t *int16s);
-#endif // _di_f_type_int16s_decrease_by_
+#ifndef _di_f_int16s_decrease_by_
+ extern f_status_t f_int16s_decrease_by(const f_array_length_t amount, f_int16s_t *int16s);
+#endif // _di_f_int16s_decrease_by_
/**
* Increase the size of the int16s array, but only if necesary.
*
* Errors (with error bit) from: f_memory_resize().
*/
-#ifndef _di_f_type_int16s_increase_
- extern f_status_t f_type_int16s_increase(const uint16_t step, f_int16s_t *int16s);
-#endif // _di_f_type_int16s_increase_
+#ifndef _di_f_int16s_increase_
+ extern f_status_t f_int16s_increase(const uint16_t step, f_int16s_t *int16s);
+#endif // _di_f_int16s_increase_
/**
* Resize the int16s array to a larger size.
*
* Errors (with error bit) from: f_memory_resize().
*/
-#ifndef _di_f_type_int16s_increase_by_
- extern f_status_t f_type_int16s_increase_by(const f_array_length_t amount, f_int16s_t *int16s);
-#endif // _di_f_type_int16s_increase_by_
+#ifndef _di_f_int16s_increase_by_
+ extern f_status_t f_int16s_increase_by(const f_array_length_t amount, f_int16s_t *int16s);
+#endif // _di_f_int16s_increase_by_
/**
* Resize the int16s array.
*
* Errors (with error bit) from: f_memory_resize().
*/
-#ifndef _di_f_type_int16s_resize_
- extern f_status_t f_type_int16s_resize(const f_array_length_t length, f_int16s_t *int16s);
-#endif // _di_f_type_int16s_resize_
+#ifndef _di_f_int16s_resize_
+ extern f_status_t f_int16s_resize(const f_array_length_t length, f_int16s_t *int16s);
+#endif // _di_f_int16s_resize_
/**
* Resize the int16ss array.
* Errors (with error bit) from: f_memory_adjust().
* Errors (with error bit) from: f_memory_destroy().
*/
-#ifndef _di_f_type_int16ss_adjust_
- extern f_status_t f_type_int16ss_adjust(const f_array_length_t length, f_int16ss_t *int16ss);
-#endif // _di_f_type_int16ss_adjust_
+#ifndef _di_f_int16ss_adjust_
+ extern f_status_t f_int16ss_adjust(const f_array_length_t length, f_int16ss_t *int16ss);
+#endif // _di_f_int16ss_adjust_
/**
* Append the source int16ss onto the destination.
*
* Errors (with error bit) from: f_memory_resize().
*/
-#ifndef _di_f_type_int16ss_append_
- extern f_status_t f_type_int16ss_append(const f_int16ss_t source, f_int16ss_t *destination);
-#endif // _di_f_type_int16ss_append_
+#ifndef _di_f_int16ss_append_
+ extern f_status_t f_int16ss_append(const f_int16ss_t source, f_int16ss_t *destination);
+#endif // _di_f_int16ss_append_
/**
* Resize the int16ss array.
* Errors (with error bit) from: f_memory_adjust().
* Errors (with error bit) from: f_memory_destroy().
*/
-#ifndef _di_f_type_int16ss_adjust_
- extern f_status_t f_type_int16ss_adjust(const f_array_length_t length, f_int16ss_t *int16ss);
-#endif // _di_f_type_int16ss_adjust_
+#ifndef _di_f_int16ss_adjust_
+ extern f_status_t f_int16ss_adjust(const f_array_length_t length, f_int16ss_t *int16ss);
+#endif // _di_f_int16ss_adjust_
/**
* Resize the int16ss array to a smaller size.
* Errors (with error bit) from: f_memory_adjust().
* Errors (with error bit) from: f_memory_destroy().
*/
-#ifndef _di_f_type_int16ss_decimate_by_
- extern f_status_t f_type_int16ss_decimate_by(const f_array_length_t amount, f_int16ss_t *int16ss);
-#endif // _di_f_type_int16ss_decimate_by_
+#ifndef _di_f_int16ss_decimate_by_
+ extern f_status_t f_int16ss_decimate_by(const f_array_length_t amount, f_int16ss_t *int16ss);
+#endif // _di_f_int16ss_decimate_by_
/**
* Resize the int16ss array to a smaller size.
* Errors (with error bit) from: f_memory_delete().
* Errors (with error bit) from: f_memory_resize().
*/
-#ifndef _di_f_type_int16ss_decrease_by_
- extern f_status_t f_type_int16ss_decrease_by(const f_array_length_t amount, f_int16ss_t *int16ss);
-#endif // _di_f_type_int16ss_decrease_by_
+#ifndef _di_f_int16ss_decrease_by_
+ extern f_status_t f_int16ss_decrease_by(const f_array_length_t amount, f_int16ss_t *int16ss);
+#endif // _di_f_int16ss_decrease_by_
/**
* Increase the size of the int16ss array, but only if necessary.
*
* Errors (with error bit) from: f_memory_resize().
*/
-#ifndef _di_f_type_int16ss_increase_
- extern f_status_t f_type_int16ss_increase(const uint16_t step, f_int16ss_t *int16ss);
-#endif // _di_f_type_int16ss_increase_
+#ifndef _di_f_int16ss_increase_
+ extern f_status_t f_int16ss_increase(const uint16_t step, f_int16ss_t *int16ss);
+#endif // _di_f_int16ss_increase_
/**
* Resize the int16ss array to a larger size.
*
* Errors (with error bit) from: f_memory_resize().
*/
-#ifndef _di_f_type_int16ss_increase_by_
- extern f_status_t f_type_int16ss_increase_by(const f_array_length_t amount, f_int16ss_t *int16ss);
-#endif // _di_f_type_int16ss_increase_by_
+#ifndef _di_f_int16ss_increase_by_
+ extern f_status_t f_int16ss_increase_by(const f_array_length_t amount, f_int16ss_t *int16ss);
+#endif // _di_f_int16ss_increase_by_
/**
* Resize the int16ss array.
* Errors (with error bit) from: f_memory_delete().
* Errors (with error bit) from: f_memory_resize().
*/
-#ifndef _di_f_type_int16ss_resize_
- extern f_status_t f_type_int16ss_resize(const f_array_length_t length, f_int16ss_t *int16ss);
-#endif // _di_f_type_int16ss_resize_
+#ifndef _di_f_int16ss_resize_
+ extern f_status_t f_int16ss_resize(const f_array_length_t length, f_int16ss_t *int16ss);
+#endif // _di_f_int16ss_resize_
/**
* Resize the string uint16s array.
*
* Errors (with error bit) from: f_memory_adjust().
*/
-#ifndef _di_f_type_uint16s_adjust_
- extern f_status_t f_type_uint16s_adjust(const f_array_length_t length, f_uint16s_t *uint16s);
-#endif // _di_f_type_uint16s_adjust_
+#ifndef _di_f_uint16s_adjust_
+ extern f_status_t f_uint16s_adjust(const f_array_length_t length, f_uint16s_t *uint16s);
+#endif // _di_f_uint16s_adjust_
/**
* Append the source uint16s onto the destination.
*
* Errors (with error bit) from: f_memory_resize().
*/
-#ifndef _di_f_type_uint16s_append_
- extern f_status_t f_type_uint16s_append(const f_uint16s_t source, f_uint16s_t *destination);
-#endif // _di_f_type_uint16s_append_
+#ifndef _di_f_uint16s_append_
+ extern f_status_t f_uint16s_append(const f_uint16s_t source, f_uint16s_t *destination);
+#endif // _di_f_uint16s_append_
/**
* Resize the string uint16s array to a smaller size.
*
* Errors (with error bit) from: f_memory_adjust().
*/
-#ifndef _di_f_type_uint16s_decimate_by_
- extern f_status_t f_type_uint16s_decimate_by(const f_array_length_t amount, f_uint16s_t *uint16s);
-#endif // _di_f_type_uint16s_decimate_by_
+#ifndef _di_f_uint16s_decimate_by_
+ extern f_status_t f_uint16s_decimate_by(const f_array_length_t amount, f_uint16s_t *uint16s);
+#endif // _di_f_uint16s_decimate_by_
/**
* Resize the string uint16s array to a smaller size.
*
* Errors (with error bit) from: f_memory_resize().
*/
-#ifndef _di_f_type_uint16s_decrease_by_
- extern f_status_t f_type_uint16s_decrease_by(const f_array_length_t amount, f_uint16s_t *uint16s);
-#endif // _di_f_type_uint16s_decrease_by_
+#ifndef _di_f_uint16s_decrease_by_
+ extern f_status_t f_uint16s_decrease_by(const f_array_length_t amount, f_uint16s_t *uint16s);
+#endif // _di_f_uint16s_decrease_by_
/**
* Increase the size of the string uint16s array, but only if necesary.
*
* Errors (with error bit) from: f_memory_resize().
*/
-#ifndef _di_f_type_uint16s_increase_
- extern f_status_t f_type_uint16s_increase(const uint16_t step, f_uint16s_t *uint16s);
-#endif // _di_f_type_uint16s_increase_
+#ifndef _di_f_uint16s_increase_
+ extern f_status_t f_uint16s_increase(const uint16_t step, f_uint16s_t *uint16s);
+#endif // _di_f_uint16s_increase_
/**
* Resize the string uint16s array to a larger size.
*
* Errors (with error bit) from: f_memory_resize().
*/
-#ifndef _di_f_type_uint16s_increase_by_
- extern f_status_t f_type_uint16s_increase_by(const f_array_length_t amount, f_uint16s_t *uint16s);
-#endif // _di_f_type_uint16s_increase_by_
+#ifndef _di_f_uint16s_increase_by_
+ extern f_status_t f_uint16s_increase_by(const f_array_length_t amount, f_uint16s_t *uint16s);
+#endif // _di_f_uint16s_increase_by_
/**
* Resize the string uint16s array.
*
* Errors (with error bit) from: f_memory_resize().
*/
-#ifndef _di_f_type_uint16s_resize_
- extern f_status_t f_type_uint16s_resize(const f_array_length_t length, f_uint16s_t *uint16s);
-#endif // _di_f_type_uint16s_resize_
+#ifndef _di_f_uint16s_resize_
+ extern f_status_t f_uint16s_resize(const f_array_length_t length, f_uint16s_t *uint16s);
+#endif // _di_f_uint16s_resize_
/**
* Resize the string uint16ss array.
* Errors (with error bit) from: f_memory_adjust().
* Errors (with error bit) from: f_memory_destroy().
*/
-#ifndef _di_f_type_uint16ss_adjust_
- extern f_status_t f_type_uint16ss_adjust(const f_array_length_t length, f_uint16ss_t *uint16ss);
-#endif // _di_f_type_uint16ss_adjust_
+#ifndef _di_f_uint16ss_adjust_
+ extern f_status_t f_uint16ss_adjust(const f_array_length_t length, f_uint16ss_t *uint16ss);
+#endif // _di_f_uint16ss_adjust_
/**
* Append the source uint16ss onto the destination.
*
* Errors (with error bit) from: f_memory_resize().
*/
-#ifndef _di_f_type_uint16ss_append_
- extern f_status_t f_type_uint16ss_append(const f_uint16ss_t source, f_uint16ss_t *destination);
-#endif // _di_f_type_uint16ss_append_
+#ifndef _di_f_uint16ss_append_
+ extern f_status_t f_uint16ss_append(const f_uint16ss_t source, f_uint16ss_t *destination);
+#endif // _di_f_uint16ss_append_
/**
* Resize the string uint16ss array.
* Errors (with error bit) from: f_memory_adjust().
* Errors (with error bit) from: f_memory_destroy().
*/
-#ifndef _di_f_type_uint16ss_adjust_
- extern f_status_t f_type_uint16ss_adjust(const f_array_length_t length, f_uint16ss_t *uint16ss);
-#endif // _di_f_type_uint16ss_adjust_
+#ifndef _di_f_uint16ss_adjust_
+ extern f_status_t f_uint16ss_adjust(const f_array_length_t length, f_uint16ss_t *uint16ss);
+#endif // _di_f_uint16ss_adjust_
/**
* Resize the string uint16ss array to a smaller size.
* Errors (with error bit) from: f_memory_adjust().
* Errors (with error bit) from: f_memory_destroy().
*/
-#ifndef _di_f_type_uint16ss_decimate_by_
- extern f_status_t f_type_uint16ss_decimate_by(const f_array_length_t amount, f_uint16ss_t *uint16ss);
-#endif // _di_f_type_uint16ss_decimate_by_
+#ifndef _di_f_uint16ss_decimate_by_
+ extern f_status_t f_uint16ss_decimate_by(const f_array_length_t amount, f_uint16ss_t *uint16ss);
+#endif // _di_f_uint16ss_decimate_by_
/**
* Resize the string uint16ss array to a smaller size.
* Errors (with error bit) from: f_memory_delete().
* Errors (with error bit) from: f_memory_resize().
*/
-#ifndef _di_f_type_uint16ss_decrease_by_
- extern f_status_t f_type_uint16ss_decrease_by(const f_array_length_t amount, f_uint16ss_t *uint16ss);
-#endif // _di_f_type_uint16ss_decrease_by_
+#ifndef _di_f_uint16ss_decrease_by_
+ extern f_status_t f_uint16ss_decrease_by(const f_array_length_t amount, f_uint16ss_t *uint16ss);
+#endif // _di_f_uint16ss_decrease_by_
/**
* Increase the size of the string uint16ss array, but only if necessary.
*
* Errors (with error bit) from: f_memory_resize().
*/
-#ifndef _di_f_type_uint16ss_increase_
- extern f_status_t f_type_uint16ss_increase(const uint16_t step, f_uint16ss_t *uint16ss);
-#endif // _di_f_type_uint16ss_increase_
+#ifndef _di_f_uint16ss_increase_
+ extern f_status_t f_uint16ss_increase(const uint16_t step, f_uint16ss_t *uint16ss);
+#endif // _di_f_uint16ss_increase_
/**
* Resize the string uint16ss array to a larger size.
*
* Errors (with error bit) from: f_memory_resize().
*/
-#ifndef _di_f_type_uint16ss_increase_by_
- extern f_status_t f_type_uint16ss_increase_by(const f_array_length_t amount, f_uint16ss_t *uint16ss);
-#endif // _di_f_type_uint16ss_increase_by_
+#ifndef _di_f_uint16ss_increase_by_
+ extern f_status_t f_uint16ss_increase_by(const f_array_length_t amount, f_uint16ss_t *uint16ss);
+#endif // _di_f_uint16ss_increase_by_
/**
* Resize the string uint16ss array.
* Errors (with error bit) from: f_memory_delete().
* Errors (with error bit) from: f_memory_resize().
*/
-#ifndef _di_f_type_uint16ss_resize_
- extern f_status_t f_type_uint16ss_resize(const f_array_length_t length, f_uint16ss_t *uint16ss);
-#endif // _di_f_type_uint16ss_resize_
+#ifndef _di_f_uint16ss_resize_
+ extern f_status_t f_uint16ss_resize(const f_array_length_t length, f_uint16ss_t *uint16ss);
+#endif // _di_f_uint16ss_resize_
#ifdef __cplusplus
} // extern "C"
extern "C" {
#endif
-#ifndef _di_f_type_int32s_adjust_
- f_status_t f_type_int32s_adjust(const f_array_length_t length, f_int32s_t *int32s) {
+#ifndef _di_f_int32s_adjust_
+ f_status_t f_int32s_adjust(const f_array_length_t length, f_int32s_t *int32s) {
#ifndef _di_level_0_parameter_checking_
if (!int32s) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
- return private_f_type_int32s_adjust(length, int32s);
+ return private_f_int32s_adjust(length, int32s);
}
-#endif // _di_f_type_int32s_adjust_
+#endif // _di_f_int32s_adjust_
-#ifndef _di_f_type_int32s_append_
- f_status_t f_type_int32s_append(const f_int32s_t source, f_int32s_t *destination) {
+#ifndef _di_f_int32s_append_
+ f_status_t f_int32s_append(const f_int32s_t source, f_int32s_t *destination) {
#ifndef _di_level_0_parameter_checking_
if (!destination) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
if (!source.used) return F_data_not;
- return private_f_type_int32s_append(source, destination);
+ return private_f_int32s_append(source, destination);
}
-#endif // _di_f_type_int32s_append_
+#endif // _di_f_int32s_append_
-#ifndef _di_f_type_int32s_decimate_by_
- f_status_t f_type_int32s_decimate_by(const f_array_length_t amount, f_int32s_t *int32s) {
+#ifndef _di_f_int32s_decimate_by_
+ f_status_t f_int32s_decimate_by(const f_array_length_t amount, f_int32s_t *int32s) {
#ifndef _di_level_0_parameter_checking_
if (!amount) return F_status_set_error(F_parameter);
if (!int32s) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
if (int32s->size - amount > 0) {
- return private_f_type_int32s_adjust(int32s->size - amount, int32s);
+ return private_f_int32s_adjust(int32s->size - amount, int32s);
}
- return private_f_type_int32s_adjust(0, int32s);
+ return private_f_int32s_adjust(0, int32s);
}
-#endif // _di_f_type_int32s_decimate_by_
+#endif // _di_f_int32s_decimate_by_
-#ifndef _di_f_type_int32s_decrease_by_
- f_status_t f_type_int32s_decrease_by(const f_array_length_t amount, f_int32s_t *int32s) {
+#ifndef _di_f_int32s_decrease_by_
+ f_status_t f_int32s_decrease_by(const f_array_length_t amount, f_int32s_t *int32s) {
#ifndef _di_level_0_parameter_checking_
if (!amount) return F_status_set_error(F_parameter);
if (!int32s) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
if (int32s->size - amount > 0) {
- return private_f_type_int32s_resize(int32s->size - amount, int32s);
+ return private_f_int32s_resize(int32s->size - amount, int32s);
}
- return private_f_type_int32s_resize(0, int32s);
+ return private_f_int32s_resize(0, int32s);
}
-#endif // _di_f_type_int32s_decrease_by_
+#endif // _di_f_int32s_decrease_by_
-#ifndef _di_f_type_int32s_increase_
- f_status_t f_type_int32s_increase(const uint16_t step, f_int32s_t *int32s) {
+#ifndef _di_f_int32s_increase_
+ f_status_t f_int32s_increase(const uint16_t step, f_int32s_t *int32s) {
#ifndef _di_level_0_parameter_checking_
if (!step) return F_status_set_error(F_parameter);
if (!int32s) return F_status_set_error(F_parameter);
size = F_array_length_t_size_d;
}
- return private_f_type_int32s_resize(size, int32s);
+ return private_f_int32s_resize(size, int32s);
}
return F_data_not;
}
-#endif // _di_f_type_int32s_increase_
+#endif // _di_f_int32s_increase_
-#ifndef _di_f_type_int32s_increase_by_
- f_status_t f_type_int32s_increase_by(const f_array_length_t amount, f_int32s_t *int32s) {
+#ifndef _di_f_int32s_increase_by_
+ f_status_t f_int32s_increase_by(const f_array_length_t amount, f_int32s_t *int32s) {
#ifndef _di_level_0_parameter_checking_
if (!amount) return F_status_set_error(F_parameter);
if (!int32s) return F_status_set_error(F_parameter);
return F_status_set_error(F_array_too_large);
}
- return private_f_type_int32s_resize(int32s->used + amount, int32s);
+ return private_f_int32s_resize(int32s->used + amount, int32s);
}
return F_data_not;
}
-#endif // _di_f_type_int32s_increase_by_
+#endif // _di_f_int32s_increase_by_
-#ifndef _di_f_type_int32s_resize_
- f_status_t f_type_int32s_resize(const f_array_length_t length, f_int32s_t *int32s) {
+#ifndef _di_f_int32s_resize_
+ f_status_t f_int32s_resize(const f_array_length_t length, f_int32s_t *int32s) {
#ifndef _di_level_0_parameter_checking_
if (!int32s) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
- return private_f_type_int32s_resize(length, int32s);
+ return private_f_int32s_resize(length, int32s);
}
-#endif // _di_f_type_int32s_resize_
+#endif // _di_f_int32s_resize_
-#ifndef _di_f_type_int32ss_adjust_
- f_status_t f_type_int32ss_adjust(const f_array_length_t length, f_int32ss_t *int32ss) {
+#ifndef _di_f_int32ss_adjust_
+ f_status_t f_int32ss_adjust(const f_array_length_t length, f_int32ss_t *int32ss) {
#ifndef _di_level_0_parameter_checking_
if (!int32ss) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
- return private_f_type_int32ss_adjust(length, int32ss);
+ return private_f_int32ss_adjust(length, int32ss);
}
-#endif // _di_f_type_int32ss_adjust_
+#endif // _di_f_int32ss_adjust_
-#ifndef _di_f_type_int32ss_append_
- f_status_t f_type_int32ss_append(const f_int32ss_t source, f_int32ss_t *destination) {
+#ifndef _di_f_int32ss_append_
+ f_status_t f_int32ss_append(const f_int32ss_t source, f_int32ss_t *destination) {
#ifndef _di_level_0_parameter_checking_
if (!destination) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
f_status_t status = F_none;
if (destination->used + source.used > destination->size) {
- status = private_f_type_int32ss_resize(destination->used + source.used, destination);
+ status = private_f_int32ss_resize(destination->used + source.used, destination);
if (F_status_is_error(status)) return status;
}
for (f_array_length_t i = 0; i < source.used; ++i, ++destination->used) {
- status = private_f_type_int32s_append(source.array[i], &destination->array[destination->used]);
+ status = private_f_int32s_append(source.array[i], &destination->array[destination->used]);
if (F_status_is_error(status)) return status;
} // for
return F_none;
}
-#endif // _di_f_type_int32ss_append_
+#endif // _di_f_int32ss_append_
-#ifndef _di_f_type_int32ss_decimate_by_
- f_status_t f_type_int32ss_decimate_by(const f_array_length_t amount, f_int32ss_t *int32ss) {
+#ifndef _di_f_int32ss_decimate_by_
+ f_status_t f_int32ss_decimate_by(const f_array_length_t amount, f_int32ss_t *int32ss) {
#ifndef _di_level_0_parameter_checking_
if (!amount) return F_status_set_error(F_parameter);
if (!int32ss) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
if (int32ss->size - amount > 0) {
- return private_f_type_int32ss_adjust(int32ss->size - amount, int32ss);
+ return private_f_int32ss_adjust(int32ss->size - amount, int32ss);
}
- return private_f_type_int32ss_adjust(0, int32ss);
+ return private_f_int32ss_adjust(0, int32ss);
}
-#endif // _di_f_type_int32ss_decimate_by_
+#endif // _di_f_int32ss_decimate_by_
-#ifndef _di_f_type_int32ss_decrease_by_
- f_status_t f_type_int32ss_decrease_by(const f_array_length_t amount, f_int32ss_t *int32ss) {
+#ifndef _di_f_int32ss_decrease_by_
+ f_status_t f_int32ss_decrease_by(const f_array_length_t amount, f_int32ss_t *int32ss) {
#ifndef _di_level_0_parameter_checking_
if (!amount) return F_status_set_error(F_parameter);
if (!int32ss) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
if (int32ss->size - amount > 0) {
- return private_f_type_int32ss_resize(int32ss->size - amount, int32ss);
+ return private_f_int32ss_resize(int32ss->size - amount, int32ss);
}
- return private_f_type_int32ss_resize(0, int32ss);
+ return private_f_int32ss_resize(0, int32ss);
}
-#endif // _di_f_type_int32ss_decrease_by_
+#endif // _di_f_int32ss_decrease_by_
-#ifndef _di_f_type_int32ss_increase_
- f_status_t f_type_int32ss_increase(const uint16_t step, f_int32ss_t *int32ss) {
+#ifndef _di_f_int32ss_increase_
+ f_status_t f_int32ss_increase(const uint16_t step, f_int32ss_t *int32ss) {
#ifndef _di_level_0_parameter_checking_
if (!step) return F_status_set_error(F_parameter);
if (!int32ss) return F_status_set_error(F_parameter);
size = F_array_length_t_size_d;
}
- return private_f_type_int32ss_resize(size, int32ss);
+ return private_f_int32ss_resize(size, int32ss);
}
return F_data_not;
}
-#endif // _di_f_type_int32ss_increase_
+#endif // _di_f_int32ss_increase_
-#ifndef _di_f_type_int32ss_increase_by_
- f_status_t f_type_int32ss_increase_by(const f_array_length_t amount, f_int32ss_t *int32ss) {
+#ifndef _di_f_int32ss_increase_by_
+ f_status_t f_int32ss_increase_by(const f_array_length_t amount, f_int32ss_t *int32ss) {
#ifndef _di_level_0_parameter_checking_
if (!amount) return F_status_set_error(F_parameter);
if (!int32ss) return F_status_set_error(F_parameter);
return F_status_set_error(F_array_too_large);
}
- return private_f_type_int32ss_resize(int32ss->used + amount, int32ss);
+ return private_f_int32ss_resize(int32ss->used + amount, int32ss);
}
return F_data_not;
}
-#endif // _di_f_type_int32ss_increase_by_
+#endif // _di_f_int32ss_increase_by_
-#ifndef _di_f_type_int32ss_resize_
- f_status_t f_type_int32ss_resize(const f_array_length_t length, f_int32ss_t *int32ss) {
+#ifndef _di_f_int32ss_resize_
+ f_status_t f_int32ss_resize(const f_array_length_t length, f_int32ss_t *int32ss) {
#ifndef _di_level_0_parameter_checking_
if (!int32ss) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
- return private_f_type_int32ss_resize(length, int32ss);
+ return private_f_int32ss_resize(length, int32ss);
}
-#endif // _di_f_type_int32ss_resize_
+#endif // _di_f_int32ss_resize_
-#ifndef _di_f_type_uint32s_adjust_
- f_status_t f_type_uint32s_adjust(const f_array_length_t length, f_uint32s_t *uint32s) {
+#ifndef _di_f_uint32s_adjust_
+ f_status_t f_uint32s_adjust(const f_array_length_t length, f_uint32s_t *uint32s) {
#ifndef _di_level_0_parameter_checking_
if (!uint32s) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
- return private_f_type_uint32s_adjust(length, uint32s);
+ return private_f_uint32s_adjust(length, uint32s);
}
-#endif // _di_f_type_uint32s_adjust_
+#endif // _di_f_uint32s_adjust_
-#ifndef _di_f_type_uint32s_append_
- f_status_t f_type_uint32s_append(const f_uint32s_t source, f_uint32s_t *destination) {
+#ifndef _di_f_uint32s_append_
+ f_status_t f_uint32s_append(const f_uint32s_t source, f_uint32s_t *destination) {
#ifndef _di_level_0_parameter_checking_
if (!destination) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
if (!source.used) return F_data_not;
- return private_f_type_uint32s_append(source, destination);
+ return private_f_uint32s_append(source, destination);
}
-#endif // _di_f_type_uint32s_append_
+#endif // _di_f_uint32s_append_
-#ifndef _di_f_type_uint32s_decimate_by_
- f_status_t f_type_uint32s_decimate_by(const f_array_length_t amount, f_uint32s_t *uint32s) {
+#ifndef _di_f_uint32s_decimate_by_
+ f_status_t f_uint32s_decimate_by(const f_array_length_t amount, f_uint32s_t *uint32s) {
#ifndef _di_level_0_parameter_checking_
if (!amount) return F_status_set_error(F_parameter);
if (!uint32s) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
if (uint32s->size - amount > 0) {
- return private_f_type_uint32s_adjust(uint32s->size - amount, uint32s);
+ return private_f_uint32s_adjust(uint32s->size - amount, uint32s);
}
- return private_f_type_uint32s_adjust(0, uint32s);
+ return private_f_uint32s_adjust(0, uint32s);
}
-#endif // _di_f_type_uint32s_decimate_by_
+#endif // _di_f_uint32s_decimate_by_
-#ifndef _di_f_type_uint32s_decrease_by_
- f_status_t f_type_uint32s_decrease_by(const f_array_length_t amount, f_uint32s_t *uint32s) {
+#ifndef _di_f_uint32s_decrease_by_
+ f_status_t f_uint32s_decrease_by(const f_array_length_t amount, f_uint32s_t *uint32s) {
#ifndef _di_level_0_parameter_checking_
if (!amount) return F_status_set_error(F_parameter);
if (!uint32s) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
if (uint32s->size - amount > 0) {
- return private_f_type_uint32s_resize(uint32s->size - amount, uint32s);
+ return private_f_uint32s_resize(uint32s->size - amount, uint32s);
}
- return private_f_type_uint32s_resize(0, uint32s);
+ return private_f_uint32s_resize(0, uint32s);
}
-#endif // _di_f_type_uint32s_decrease_by_
+#endif // _di_f_uint32s_decrease_by_
-#ifndef _di_f_type_uint32s_increase_
- f_status_t f_type_uint32s_increase(const uint16_t step, f_uint32s_t *uint32s) {
+#ifndef _di_f_uint32s_increase_
+ f_status_t f_uint32s_increase(const uint16_t step, f_uint32s_t *uint32s) {
#ifndef _di_level_0_parameter_checking_
if (!step) return F_status_set_error(F_parameter);
if (!uint32s) return F_status_set_error(F_parameter);
size = F_array_length_t_size_d;
}
- return private_f_type_uint32s_resize(size, uint32s);
+ return private_f_uint32s_resize(size, uint32s);
}
return F_data_not;
}
-#endif // _di_f_type_uint32s_increase_
+#endif // _di_f_uint32s_increase_
-#ifndef _di_f_type_uint32s_increase_by_
- f_status_t f_type_uint32s_increase_by(const f_array_length_t amount, f_uint32s_t *uint32s) {
+#ifndef _di_f_uint32s_increase_by_
+ f_status_t f_uint32s_increase_by(const f_array_length_t amount, f_uint32s_t *uint32s) {
#ifndef _di_level_0_parameter_checking_
if (!amount) return F_status_set_error(F_parameter);
if (!uint32s) return F_status_set_error(F_parameter);
return F_status_set_error(F_array_too_large);
}
- return private_f_type_uint32s_resize(uint32s->used + amount, uint32s);
+ return private_f_uint32s_resize(uint32s->used + amount, uint32s);
}
return F_data_not;
}
-#endif // _di_f_type_uint32s_increase_by_
+#endif // _di_f_uint32s_increase_by_
-#ifndef _di_f_type_uint32s_resize_
- f_status_t f_type_uint32s_resize(const f_array_length_t length, f_uint32s_t *uint32s) {
+#ifndef _di_f_uint32s_resize_
+ f_status_t f_uint32s_resize(const f_array_length_t length, f_uint32s_t *uint32s) {
#ifndef _di_level_0_parameter_checking_
if (!uint32s) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
- return private_f_type_uint32s_resize(length, uint32s);
+ return private_f_uint32s_resize(length, uint32s);
}
-#endif // _di_f_type_uint32s_resize_
+#endif // _di_f_uint32s_resize_
-#ifndef _di_f_type_uint32ss_adjust_
- f_status_t f_type_uint32ss_adjust(const f_array_length_t length, f_uint32ss_t *uint32ss) {
+#ifndef _di_f_uint32ss_adjust_
+ f_status_t f_uint32ss_adjust(const f_array_length_t length, f_uint32ss_t *uint32ss) {
#ifndef _di_level_0_parameter_checking_
if (!uint32ss) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
- return private_f_type_uint32ss_adjust(length, uint32ss);
+ return private_f_uint32ss_adjust(length, uint32ss);
}
-#endif // _di_f_type_uint32ss_adjust_
+#endif // _di_f_uint32ss_adjust_
-#ifndef _di_f_type_uint32ss_append_
- f_status_t f_type_uint32ss_append(const f_uint32ss_t source, f_uint32ss_t *destination) {
+#ifndef _di_f_uint32ss_append_
+ f_status_t f_uint32ss_append(const f_uint32ss_t source, f_uint32ss_t *destination) {
#ifndef _di_level_0_parameter_checking_
if (!destination) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
f_status_t status = F_none;
if (destination->used + source.used > destination->size) {
- status = private_f_type_uint32ss_resize(destination->used + source.used, destination);
+ status = private_f_uint32ss_resize(destination->used + source.used, destination);
if (F_status_is_error(status)) return status;
}
for (f_array_length_t i = 0; i < source.used; ++i, ++destination->used) {
- status = private_f_type_uint32s_append(source.array[i], &destination->array[destination->used]);
+ status = private_f_uint32s_append(source.array[i], &destination->array[destination->used]);
if (F_status_is_error(status)) return status;
} // for
return F_none;
}
-#endif // _di_f_type_uint32ss_append_
+#endif // _di_f_uint32ss_append_
-#ifndef _di_f_type_uint32ss_decimate_by_
- f_status_t f_type_uint32ss_decimate_by(const f_array_length_t amount, f_uint32ss_t *uint32ss) {
+#ifndef _di_f_uint32ss_decimate_by_
+ f_status_t f_uint32ss_decimate_by(const f_array_length_t amount, f_uint32ss_t *uint32ss) {
#ifndef _di_level_0_parameter_checking_
if (!amount) return F_status_set_error(F_parameter);
if (!uint32ss) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
if (uint32ss->size - amount > 0) {
- return private_f_type_uint32ss_adjust(uint32ss->size - amount, uint32ss);
+ return private_f_uint32ss_adjust(uint32ss->size - amount, uint32ss);
}
- return private_f_type_uint32ss_adjust(0, uint32ss);
+ return private_f_uint32ss_adjust(0, uint32ss);
}
-#endif // _di_f_type_uint32ss_decimate_by_
+#endif // _di_f_uint32ss_decimate_by_
-#ifndef _di_f_type_uint32ss_decrease_by_
- f_status_t f_type_uint32ss_decrease_by(const f_array_length_t amount, f_uint32ss_t *uint32ss) {
+#ifndef _di_f_uint32ss_decrease_by_
+ f_status_t f_uint32ss_decrease_by(const f_array_length_t amount, f_uint32ss_t *uint32ss) {
#ifndef _di_level_0_parameter_checking_
if (!amount) return F_status_set_error(F_parameter);
if (!uint32ss) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
if (uint32ss->size - amount > 0) {
- return private_f_type_uint32ss_resize(uint32ss->size - amount, uint32ss);
+ return private_f_uint32ss_resize(uint32ss->size - amount, uint32ss);
}
- return private_f_type_uint32ss_resize(0, uint32ss);
+ return private_f_uint32ss_resize(0, uint32ss);
}
-#endif // _di_f_type_uint32ss_decrease_by_
+#endif // _di_f_uint32ss_decrease_by_
-#ifndef _di_f_type_uint32ss_increase_
- f_status_t f_type_uint32ss_increase(const uint16_t step, f_uint32ss_t *uint32ss) {
+#ifndef _di_f_uint32ss_increase_
+ f_status_t f_uint32ss_increase(const uint16_t step, f_uint32ss_t *uint32ss) {
#ifndef _di_level_0_parameter_checking_
if (!step) return F_status_set_error(F_parameter);
if (!uint32ss) return F_status_set_error(F_parameter);
size = F_array_length_t_size_d;
}
- return private_f_type_uint32ss_resize(size, uint32ss);
+ return private_f_uint32ss_resize(size, uint32ss);
}
return F_data_not;
}
-#endif // _di_f_type_uint32ss_increase_
+#endif // _di_f_uint32ss_increase_
-#ifndef _di_f_type_uint32ss_increase_by_
- f_status_t f_type_uint32ss_increase_by(const f_array_length_t amount, f_uint32ss_t *uint32ss) {
+#ifndef _di_f_uint32ss_increase_by_
+ f_status_t f_uint32ss_increase_by(const f_array_length_t amount, f_uint32ss_t *uint32ss) {
#ifndef _di_level_0_parameter_checking_
if (!amount) return F_status_set_error(F_parameter);
if (!uint32ss) return F_status_set_error(F_parameter);
return F_status_set_error(F_array_too_large);
}
- return private_f_type_uint32ss_resize(uint32ss->used + amount, uint32ss);
+ return private_f_uint32ss_resize(uint32ss->used + amount, uint32ss);
}
return F_data_not;
}
-#endif // _di_f_type_uint32ss_increase_by_
+#endif // _di_f_uint32ss_increase_by_
-#ifndef _di_f_type_uint32ss_resize_
- f_status_t f_type_uint32ss_resize(const f_array_length_t length, f_uint32ss_t *uint32ss) {
+#ifndef _di_f_uint32ss_resize_
+ f_status_t f_uint32ss_resize(const f_array_length_t length, f_uint32ss_t *uint32ss) {
#ifndef _di_level_0_parameter_checking_
if (!uint32ss) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
- return private_f_type_uint32ss_resize(length, uint32ss);
+ return private_f_uint32ss_resize(length, uint32ss);
}
-#endif // _di_f_type_uint32ss_resize_
+#endif // _di_f_uint32ss_resize_
#ifdef __cplusplus
} // extern "C"
*
* Errors (with error bit) from: f_memory_adjust().
*/
-#ifndef _di_f_type_int32s_adjust_
- extern f_status_t f_type_int32s_adjust(const f_array_length_t length, f_int32s_t *int32s);
-#endif // _di_f_type_int32s_adjust_
+#ifndef _di_f_int32s_adjust_
+ extern f_status_t f_int32s_adjust(const f_array_length_t length, f_int32s_t *int32s);
+#endif // _di_f_int32s_adjust_
/**
* Append the source int32s onto the destination.
*
* Errors (with error bit) from: f_memory_resize().
*/
-#ifndef _di_f_type_int32s_append_
- extern f_status_t f_type_int32s_append(const f_int32s_t source, f_int32s_t *destination);
-#endif // _di_f_type_int32s_append_
+#ifndef _di_f_int32s_append_
+ extern f_status_t f_int32s_append(const f_int32s_t source, f_int32s_t *destination);
+#endif // _di_f_int32s_append_
/**
* Resize the int32s array to a smaller size.
*
* Errors (with error bit) from: f_memory_adjust().
*/
-#ifndef _di_f_type_int32s_decimate_by_
- extern f_status_t f_type_int32s_decimate_by(const f_array_length_t amount, f_int32s_t *int32s);
-#endif // _di_f_type_int32s_decimate_by_
+#ifndef _di_f_int32s_decimate_by_
+ extern f_status_t f_int32s_decimate_by(const f_array_length_t amount, f_int32s_t *int32s);
+#endif // _di_f_int32s_decimate_by_
/**
* Resize the int32s array to a smaller size.
*
* Errors (with error bit) from: f_memory_resize().
*/
-#ifndef _di_f_type_int32s_decrease_by_
- extern f_status_t f_type_int32s_decrease_by(const f_array_length_t amount, f_int32s_t *int32s);
-#endif // _di_f_type_int32s_decrease_by_
+#ifndef _di_f_int32s_decrease_by_
+ extern f_status_t f_int32s_decrease_by(const f_array_length_t amount, f_int32s_t *int32s);
+#endif // _di_f_int32s_decrease_by_
/**
* Increase the size of the int32s array, but only if necesary.
*
* Errors (with error bit) from: f_memory_resize().
*/
-#ifndef _di_f_type_int32s_increase_
- extern f_status_t f_type_int32s_increase(const uint16_t step, f_int32s_t *int32s);
-#endif // _di_f_type_int32s_increase_
+#ifndef _di_f_int32s_increase_
+ extern f_status_t f_int32s_increase(const uint16_t step, f_int32s_t *int32s);
+#endif // _di_f_int32s_increase_
/**
* Resize the int32s array to a larger size.
*
* Errors (with error bit) from: f_memory_resize().
*/
-#ifndef _di_f_type_int32s_increase_by_
- extern f_status_t f_type_int32s_increase_by(const f_array_length_t amount, f_int32s_t *int32s);
-#endif // _di_f_type_int32s_increase_by_
+#ifndef _di_f_int32s_increase_by_
+ extern f_status_t f_int32s_increase_by(const f_array_length_t amount, f_int32s_t *int32s);
+#endif // _di_f_int32s_increase_by_
/**
* Resize the int32s array.
*
* Errors (with error bit) from: f_memory_resize().
*/
-#ifndef _di_f_type_int32s_resize_
- extern f_status_t f_type_int32s_resize(const f_array_length_t length, f_int32s_t *int32s);
-#endif // _di_f_type_int32s_resize_
+#ifndef _di_f_int32s_resize_
+ extern f_status_t f_int32s_resize(const f_array_length_t length, f_int32s_t *int32s);
+#endif // _di_f_int32s_resize_
/**
* Resize the int32ss array.
* Errors (with error bit) from: f_memory_adjust().
* Errors (with error bit) from: f_memory_destroy().
*/
-#ifndef _di_f_type_int32ss_adjust_
- extern f_status_t f_type_int32ss_adjust(const f_array_length_t length, f_int32ss_t *int32ss);
-#endif // _di_f_type_int32ss_adjust_
+#ifndef _di_f_int32ss_adjust_
+ extern f_status_t f_int32ss_adjust(const f_array_length_t length, f_int32ss_t *int32ss);
+#endif // _di_f_int32ss_adjust_
/**
* Append the source int32ss onto the destination.
*
* Errors (with error bit) from: f_memory_resize().
*/
-#ifndef _di_f_type_int32ss_append_
- extern f_status_t f_type_int32ss_append(const f_int32ss_t source, f_int32ss_t *destination);
-#endif // _di_f_type_int32ss_append_
+#ifndef _di_f_int32ss_append_
+ extern f_status_t f_int32ss_append(const f_int32ss_t source, f_int32ss_t *destination);
+#endif // _di_f_int32ss_append_
/**
* Resize the int32ss array.
* Errors (with error bit) from: f_memory_adjust().
* Errors (with error bit) from: f_memory_destroy().
*/
-#ifndef _di_f_type_int32ss_adjust_
- extern f_status_t f_type_int32ss_adjust(const f_array_length_t length, f_int32ss_t *int32ss);
-#endif // _di_f_type_int32ss_adjust_
+#ifndef _di_f_int32ss_adjust_
+ extern f_status_t f_int32ss_adjust(const f_array_length_t length, f_int32ss_t *int32ss);
+#endif // _di_f_int32ss_adjust_
/**
* Resize the int32ss array to a smaller size.
* Errors (with error bit) from: f_memory_adjust().
* Errors (with error bit) from: f_memory_destroy().
*/
-#ifndef _di_f_type_int32ss_decimate_by_
- extern f_status_t f_type_int32ss_decimate_by(const f_array_length_t amount, f_int32ss_t *int32ss);
-#endif // _di_f_type_int32ss_decimate_by_
+#ifndef _di_f_int32ss_decimate_by_
+ extern f_status_t f_int32ss_decimate_by(const f_array_length_t amount, f_int32ss_t *int32ss);
+#endif // _di_f_int32ss_decimate_by_
/**
* Resize the int32ss array to a smaller size.
* Errors (with error bit) from: f_memory_delete().
* Errors (with error bit) from: f_memory_resize().
*/
-#ifndef _di_f_type_int32ss_decrease_by_
- extern f_status_t f_type_int32ss_decrease_by(const f_array_length_t amount, f_int32ss_t *int32ss);
-#endif // _di_f_type_int32ss_decrease_by_
+#ifndef _di_f_int32ss_decrease_by_
+ extern f_status_t f_int32ss_decrease_by(const f_array_length_t amount, f_int32ss_t *int32ss);
+#endif // _di_f_int32ss_decrease_by_
/**
* Increase the size of the int32ss array, but only if necessary.
*
* Errors (with error bit) from: f_memory_resize().
*/
-#ifndef _di_f_type_int32ss_increase_
- extern f_status_t f_type_int32ss_increase(const uint16_t step, f_int32ss_t *int32ss);
-#endif // _di_f_type_int32ss_increase_
+#ifndef _di_f_int32ss_increase_
+ extern f_status_t f_int32ss_increase(const uint16_t step, f_int32ss_t *int32ss);
+#endif // _di_f_int32ss_increase_
/**
* Resize the int32ss array to a larger size.
*
* Errors (with error bit) from: f_memory_resize().
*/
-#ifndef _di_f_type_int32ss_increase_by_
- extern f_status_t f_type_int32ss_increase_by(const f_array_length_t amount, f_int32ss_t *int32ss);
-#endif // _di_f_type_int32ss_increase_by_
+#ifndef _di_f_int32ss_increase_by_
+ extern f_status_t f_int32ss_increase_by(const f_array_length_t amount, f_int32ss_t *int32ss);
+#endif // _di_f_int32ss_increase_by_
/**
* Resize the int32ss array.
* Errors (with error bit) from: f_memory_delete().
* Errors (with error bit) from: f_memory_resize().
*/
-#ifndef _di_f_type_int32ss_resize_
- extern f_status_t f_type_int32ss_resize(const f_array_length_t length, f_int32ss_t *int32ss);
-#endif // _di_f_type_int32ss_resize_
+#ifndef _di_f_int32ss_resize_
+ extern f_status_t f_int32ss_resize(const f_array_length_t length, f_int32ss_t *int32ss);
+#endif // _di_f_int32ss_resize_
/**
* Resize the string uint32s array.
*
* Errors (with error bit) from: f_memory_adjust().
*/
-#ifndef _di_f_type_uint32s_adjust_
- extern f_status_t f_type_uint32s_adjust(const f_array_length_t length, f_uint32s_t *uint32s);
-#endif // _di_f_type_uint32s_adjust_
+#ifndef _di_f_uint32s_adjust_
+ extern f_status_t f_uint32s_adjust(const f_array_length_t length, f_uint32s_t *uint32s);
+#endif // _di_f_uint32s_adjust_
/**
* Append the source uint32s onto the destination.
*
* Errors (with error bit) from: f_memory_resize().
*/
-#ifndef _di_f_type_uint32s_append_
- extern f_status_t f_type_uint32s_append(const f_uint32s_t source, f_uint32s_t *destination);
-#endif // _di_f_type_uint32s_append_
+#ifndef _di_f_uint32s_append_
+ extern f_status_t f_uint32s_append(const f_uint32s_t source, f_uint32s_t *destination);
+#endif // _di_f_uint32s_append_
/**
* Resize the string uint32s array to a smaller size.
*
* Errors (with error bit) from: f_memory_adjust().
*/
-#ifndef _di_f_type_uint32s_decimate_by_
- extern f_status_t f_type_uint32s_decimate_by(const f_array_length_t amount, f_uint32s_t *uint32s);
-#endif // _di_f_type_uint32s_decimate_by_
+#ifndef _di_f_uint32s_decimate_by_
+ extern f_status_t f_uint32s_decimate_by(const f_array_length_t amount, f_uint32s_t *uint32s);
+#endif // _di_f_uint32s_decimate_by_
/**
* Resize the string uint32s array to a smaller size.
*
* Errors (with error bit) from: f_memory_resize().
*/
-#ifndef _di_f_type_uint32s_decrease_by_
- extern f_status_t f_type_uint32s_decrease_by(const f_array_length_t amount, f_uint32s_t *uint32s);
-#endif // _di_f_type_uint32s_decrease_by_
+#ifndef _di_f_uint32s_decrease_by_
+ extern f_status_t f_uint32s_decrease_by(const f_array_length_t amount, f_uint32s_t *uint32s);
+#endif // _di_f_uint32s_decrease_by_
/**
* Increase the size of the string uint32s array, but only if necesary.
*
* Errors (with error bit) from: f_memory_resize().
*/
-#ifndef _di_f_type_uint32s_increase_
- extern f_status_t f_type_uint32s_increase(const uint16_t step, f_uint32s_t *uint32s);
-#endif // _di_f_type_uint32s_increase_
+#ifndef _di_f_uint32s_increase_
+ extern f_status_t f_uint32s_increase(const uint16_t step, f_uint32s_t *uint32s);
+#endif // _di_f_uint32s_increase_
/**
* Resize the string uint32s array to a larger size.
*
* Errors (with error bit) from: f_memory_resize().
*/
-#ifndef _di_f_type_uint32s_increase_by_
- extern f_status_t f_type_uint32s_increase_by(const f_array_length_t amount, f_uint32s_t *uint32s);
-#endif // _di_f_type_uint32s_increase_by_
+#ifndef _di_f_uint32s_increase_by_
+ extern f_status_t f_uint32s_increase_by(const f_array_length_t amount, f_uint32s_t *uint32s);
+#endif // _di_f_uint32s_increase_by_
/**
* Resize the string uint32s array.
*
* Errors (with error bit) from: f_memory_resize().
*/
-#ifndef _di_f_type_uint32s_resize_
- extern f_status_t f_type_uint32s_resize(const f_array_length_t length, f_uint32s_t *uint32s);
-#endif // _di_f_type_uint32s_resize_
+#ifndef _di_f_uint32s_resize_
+ extern f_status_t f_uint32s_resize(const f_array_length_t length, f_uint32s_t *uint32s);
+#endif // _di_f_uint32s_resize_
/**
* Resize the string uint32ss array.
* Errors (with error bit) from: f_memory_adjust().
* Errors (with error bit) from: f_memory_destroy().
*/
-#ifndef _di_f_type_uint32ss_adjust_
- extern f_status_t f_type_uint32ss_adjust(const f_array_length_t length, f_uint32ss_t *uint32ss);
-#endif // _di_f_type_uint32ss_adjust_
+#ifndef _di_f_uint32ss_adjust_
+ extern f_status_t f_uint32ss_adjust(const f_array_length_t length, f_uint32ss_t *uint32ss);
+#endif // _di_f_uint32ss_adjust_
/**
* Append the source uint32ss onto the destination.
*
* Errors (with error bit) from: f_memory_resize().
*/
-#ifndef _di_f_type_uint32ss_append_
- extern f_status_t f_type_uint32ss_append(const f_uint32ss_t source, f_uint32ss_t *destination);
-#endif // _di_f_type_uint32ss_append_
+#ifndef _di_f_uint32ss_append_
+ extern f_status_t f_uint32ss_append(const f_uint32ss_t source, f_uint32ss_t *destination);
+#endif // _di_f_uint32ss_append_
/**
* Resize the string uint32ss array.
* Errors (with error bit) from: f_memory_adjust().
* Errors (with error bit) from: f_memory_destroy().
*/
-#ifndef _di_f_type_uint32ss_adjust_
- extern f_status_t f_type_uint32ss_adjust(const f_array_length_t length, f_uint32ss_t *uint32ss);
-#endif // _di_f_type_uint32ss_adjust_
+#ifndef _di_f_uint32ss_adjust_
+ extern f_status_t f_uint32ss_adjust(const f_array_length_t length, f_uint32ss_t *uint32ss);
+#endif // _di_f_uint32ss_adjust_
/**
* Resize the string uint32ss array to a smaller size.
* Errors (with error bit) from: f_memory_adjust().
* Errors (with error bit) from: f_memory_destroy().
*/
-#ifndef _di_f_type_uint32ss_decimate_by_
- extern f_status_t f_type_uint32ss_decimate_by(const f_array_length_t amount, f_uint32ss_t *uint32ss);
-#endif // _di_f_type_uint32ss_decimate_by_
+#ifndef _di_f_uint32ss_decimate_by_
+ extern f_status_t f_uint32ss_decimate_by(const f_array_length_t amount, f_uint32ss_t *uint32ss);
+#endif // _di_f_uint32ss_decimate_by_
/**
* Resize the string uint32ss array to a smaller size.
* Errors (with error bit) from: f_memory_delete().
* Errors (with error bit) from: f_memory_resize().
*/
-#ifndef _di_f_type_uint32ss_decrease_by_
- extern f_status_t f_type_uint32ss_decrease_by(const f_array_length_t amount, f_uint32ss_t *uint32ss);
-#endif // _di_f_type_uint32ss_decrease_by_
+#ifndef _di_f_uint32ss_decrease_by_
+ extern f_status_t f_uint32ss_decrease_by(const f_array_length_t amount, f_uint32ss_t *uint32ss);
+#endif // _di_f_uint32ss_decrease_by_
/**
* Increase the size of the string uint32ss array, but only if necessary.
*
* Errors (with error bit) from: f_memory_resize().
*/
-#ifndef _di_f_type_uint32ss_increase_
- extern f_status_t f_type_uint32ss_increase(const uint16_t step, f_uint32ss_t *uint32ss);
-#endif // _di_f_type_uint32ss_increase_
+#ifndef _di_f_uint32ss_increase_
+ extern f_status_t f_uint32ss_increase(const uint16_t step, f_uint32ss_t *uint32ss);
+#endif // _di_f_uint32ss_increase_
/**
* Resize the string uint32ss array to a larger size.
*
* Errors (with error bit) from: f_memory_resize().
*/
-#ifndef _di_f_type_uint32ss_increase_by_
- extern f_status_t f_type_uint32ss_increase_by(const f_array_length_t amount, f_uint32ss_t *uint32ss);
-#endif // _di_f_type_uint32ss_increase_by_
+#ifndef _di_f_uint32ss_increase_by_
+ extern f_status_t f_uint32ss_increase_by(const f_array_length_t amount, f_uint32ss_t *uint32ss);
+#endif // _di_f_uint32ss_increase_by_
/**
* Resize the string uint32ss array.
* Errors (with error bit) from: f_memory_delete().
* Errors (with error bit) from: f_memory_resize().
*/
-#ifndef _di_f_type_uint32ss_resize_
- extern f_status_t f_type_uint32ss_resize(const f_array_length_t length, f_uint32ss_t *uint32ss);
-#endif // _di_f_type_uint32ss_resize_
+#ifndef _di_f_uint32ss_resize_
+ extern f_status_t f_uint32ss_resize(const f_array_length_t length, f_uint32ss_t *uint32ss);
+#endif // _di_f_uint32ss_resize_
#ifdef __cplusplus
} // extern "C"
extern "C" {
#endif
-#ifndef _di_f_type_int64s_adjust_
- f_status_t f_type_int64s_adjust(const f_array_length_t length, f_int64s_t *int64s) {
+#ifndef _di_f_int64s_adjust_
+ f_status_t f_int64s_adjust(const f_array_length_t length, f_int64s_t *int64s) {
#ifndef _di_level_0_parameter_checking_
if (!int64s) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
- return private_f_type_int64s_adjust(length, int64s);
+ return private_f_int64s_adjust(length, int64s);
}
-#endif // _di_f_type_int64s_adjust_
+#endif // _di_f_int64s_adjust_
-#ifndef _di_f_type_int64s_append_
- f_status_t f_type_int64s_append(const f_int64s_t source, f_int64s_t *destination) {
+#ifndef _di_f_int64s_append_
+ f_status_t f_int64s_append(const f_int64s_t source, f_int64s_t *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_type_int64s_append(source, destination);
+ return private_f_int64s_append(source, destination);
}
-#endif // _di_f_type_int64s_append_
+#endif // _di_f_int64s_append_
-#ifndef _di_f_type_int64s_decimate_by_
- f_status_t f_type_int64s_decimate_by(const f_array_length_t amount, f_int64s_t *int64s) {
+#ifndef _di_f_int64s_decimate_by_
+ f_status_t f_int64s_decimate_by(const f_array_length_t amount, f_int64s_t *int64s) {
#ifndef _di_level_0_parameter_checking_
if (!amount) return F_status_set_error(F_parameter);
if (!int64s) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
if (int64s->size - amount > 0) {
- return private_f_type_int64s_adjust(int64s->size - amount, int64s);
+ return private_f_int64s_adjust(int64s->size - amount, int64s);
}
- return private_f_type_int64s_adjust(0, int64s);
+ return private_f_int64s_adjust(0, int64s);
}
-#endif // _di_f_type_int64s_decimate_by_
+#endif // _di_f_int64s_decimate_by_
-#ifndef _di_f_type_int64s_decrease_by_
- f_status_t f_type_int64s_decrease_by(const f_array_length_t amount, f_int64s_t *int64s) {
+#ifndef _di_f_int64s_decrease_by_
+ f_status_t f_int64s_decrease_by(const f_array_length_t amount, f_int64s_t *int64s) {
#ifndef _di_level_0_parameter_checking_
if (!amount) return F_status_set_error(F_parameter);
if (!int64s) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
if (int64s->size - amount > 0) {
- return private_f_type_int64s_resize(int64s->size - amount, int64s);
+ return private_f_int64s_resize(int64s->size - amount, int64s);
}
- return private_f_type_int64s_resize(0, int64s);
+ return private_f_int64s_resize(0, int64s);
}
-#endif // _di_f_type_int64s_decrease_by_
+#endif // _di_f_int64s_decrease_by_
-#ifndef _di_f_type_int64s_increase_
- f_status_t f_type_int64s_increase(const uint16_t step, f_int64s_t *int64s) {
+#ifndef _di_f_int64s_increase_
+ f_status_t f_int64s_increase(const uint16_t step, f_int64s_t *int64s) {
#ifndef _di_level_0_parameter_checking_
if (!step) return F_status_set_error(F_parameter);
if (!int64s) return F_status_set_error(F_parameter);
size = F_array_length_t_size_d;
}
- return private_f_type_int64s_resize(size, int64s);
+ return private_f_int64s_resize(size, int64s);
}
return F_data_not;
}
-#endif // _di_f_type_int64s_increase_
+#endif // _di_f_int64s_increase_
-#ifndef _di_f_type_int64s_increase_by_
- f_status_t f_type_int64s_increase_by(const f_array_length_t amount, f_int64s_t *int64s) {
+#ifndef _di_f_int64s_increase_by_
+ f_status_t f_int64s_increase_by(const f_array_length_t amount, f_int64s_t *int64s) {
#ifndef _di_level_0_parameter_checking_
if (!amount) return F_status_set_error(F_parameter);
if (!int64s) return F_status_set_error(F_parameter);
return F_status_set_error(F_array_too_large);
}
- return private_f_type_int64s_resize(int64s->used + amount, int64s);
+ return private_f_int64s_resize(int64s->used + amount, int64s);
}
return F_data_not;
}
-#endif // _di_f_type_int64s_increase_by_
+#endif // _di_f_int64s_increase_by_
-#ifndef _di_f_type_int64s_resize_
- f_status_t f_type_int64s_resize(const f_array_length_t length, f_int64s_t *int64s) {
+#ifndef _di_f_int64s_resize_
+ f_status_t f_int64s_resize(const f_array_length_t length, f_int64s_t *int64s) {
#ifndef _di_level_0_parameter_checking_
if (!int64s) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
- return private_f_type_int64s_resize(length, int64s);
+ return private_f_int64s_resize(length, int64s);
}
-#endif // _di_f_type_int64s_resize_
+#endif // _di_f_int64s_resize_
-#ifndef _di_f_type_int64ss_adjust_
- f_status_t f_type_int64ss_adjust(const f_array_length_t length, f_int64ss_t *int64ss) {
+#ifndef _di_f_int64ss_adjust_
+ f_status_t f_int64ss_adjust(const f_array_length_t length, f_int64ss_t *int64ss) {
#ifndef _di_level_0_parameter_checking_
if (!int64ss) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
- return private_f_type_int64ss_adjust(length, int64ss);
+ return private_f_int64ss_adjust(length, int64ss);
}
-#endif // _di_f_type_int64ss_adjust_
+#endif // _di_f_int64ss_adjust_
-#ifndef _di_f_type_int64ss_append_
- f_status_t f_type_int64ss_append(const f_int64ss_t source, f_int64ss_t *destination) {
+#ifndef _di_f_int64ss_append_
+ f_status_t f_int64ss_append(const f_int64ss_t source, f_int64ss_t *destination) {
#ifndef _di_level_0_parameter_checking_
if (!destination) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
f_status_t status = F_none;
if (destination->used + source.used > destination->size) {
- status = private_f_type_int64ss_resize(destination->used + source.used, destination);
+ status = private_f_int64ss_resize(destination->used + source.used, destination);
if (F_status_is_error(status)) return status;
}
for (f_array_length_t i = 0; i < source.used; ++i, ++destination->used) {
- status = private_f_type_int64s_append(source.array[i], &destination->array[destination->used]);
+ status = private_f_int64s_append(source.array[i], &destination->array[destination->used]);
if (F_status_is_error(status)) return status;
} // for
return F_none;
}
-#endif // _di_f_type_int64ss_append_
+#endif // _di_f_int64ss_append_
-#ifndef _di_f_type_int64ss_decimate_by_
- f_status_t f_type_int64ss_decimate_by(const f_array_length_t amount, f_int64ss_t *int64ss) {
+#ifndef _di_f_int64ss_decimate_by_
+ f_status_t f_int64ss_decimate_by(const f_array_length_t amount, f_int64ss_t *int64ss) {
#ifndef _di_level_0_parameter_checking_
if (!amount) return F_status_set_error(F_parameter);
if (!int64ss) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
if (int64ss->size - amount > 0) {
- return private_f_type_int64ss_adjust(int64ss->size - amount, int64ss);
+ return private_f_int64ss_adjust(int64ss->size - amount, int64ss);
}
- return private_f_type_int64ss_adjust(0, int64ss);
+ return private_f_int64ss_adjust(0, int64ss);
}
-#endif // _di_f_type_int64ss_decimate_by_
+#endif // _di_f_int64ss_decimate_by_
-#ifndef _di_f_type_int64ss_decrease_by_
- f_status_t f_type_int64ss_decrease_by(const f_array_length_t amount, f_int64ss_t *int64ss) {
+#ifndef _di_f_int64ss_decrease_by_
+ f_status_t f_int64ss_decrease_by(const f_array_length_t amount, f_int64ss_t *int64ss) {
#ifndef _di_level_0_parameter_checking_
if (!amount) return F_status_set_error(F_parameter);
if (!int64ss) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
if (int64ss->size - amount > 0) {
- return private_f_type_int64ss_resize(int64ss->size - amount, int64ss);
+ return private_f_int64ss_resize(int64ss->size - amount, int64ss);
}
- return private_f_type_int64ss_resize(0, int64ss);
+ return private_f_int64ss_resize(0, int64ss);
}
-#endif // _di_f_type_int64ss_decrease_by_
+#endif // _di_f_int64ss_decrease_by_
-#ifndef _di_f_type_int64ss_increase_
- f_status_t f_type_int64ss_increase(const uint16_t step, f_int64ss_t *int64ss) {
+#ifndef _di_f_int64ss_increase_
+ f_status_t f_int64ss_increase(const uint16_t step, f_int64ss_t *int64ss) {
#ifndef _di_level_0_parameter_checking_
if (!step) return F_status_set_error(F_parameter);
if (!int64ss) return F_status_set_error(F_parameter);
size = F_array_length_t_size_d;
}
- return private_f_type_int64ss_resize(size, int64ss);
+ return private_f_int64ss_resize(size, int64ss);
}
return F_data_not;
}
-#endif // _di_f_type_int64ss_increase_
+#endif // _di_f_int64ss_increase_
-#ifndef _di_f_type_int64ss_increase_by_
- f_status_t f_type_int64ss_increase_by(const f_array_length_t amount, f_int64ss_t *int64ss) {
+#ifndef _di_f_int64ss_increase_by_
+ f_status_t f_int64ss_increase_by(const f_array_length_t amount, f_int64ss_t *int64ss) {
#ifndef _di_level_0_parameter_checking_
if (!amount) return F_status_set_error(F_parameter);
if (!int64ss) return F_status_set_error(F_parameter);
return F_status_set_error(F_array_too_large);
}
- return private_f_type_int64ss_resize(int64ss->used + amount, int64ss);
+ return private_f_int64ss_resize(int64ss->used + amount, int64ss);
}
return F_data_not;
}
-#endif // _di_f_type_int64ss_increase_by_
+#endif // _di_f_int64ss_increase_by_
-#ifndef _di_f_type_int64ss_resize_
- f_status_t f_type_int64ss_resize(const f_array_length_t length, f_int64ss_t *int64ss) {
+#ifndef _di_f_int64ss_resize_
+ f_status_t f_int64ss_resize(const f_array_length_t length, f_int64ss_t *int64ss) {
#ifndef _di_level_0_parameter_checking_
if (!int64ss) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
- return private_f_type_int64ss_resize(length, int64ss);
+ return private_f_int64ss_resize(length, int64ss);
}
-#endif // _di_f_type_int64ss_resize_
+#endif // _di_f_int64ss_resize_
-#ifndef _di_f_type_uint64s_adjust_
- f_status_t f_type_uint64s_adjust(const f_array_length_t length, f_uint64s_t *uint64s) {
+#ifndef _di_f_uint64s_adjust_
+ f_status_t f_uint64s_adjust(const f_array_length_t length, f_uint64s_t *uint64s) {
#ifndef _di_level_0_parameter_checking_
if (!uint64s) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
- return private_f_type_uint64s_adjust(length, uint64s);
+ return private_f_uint64s_adjust(length, uint64s);
}
-#endif // _di_f_type_uint64s_adjust_
+#endif // _di_f_uint64s_adjust_
-#ifndef _di_f_type_uint64s_append_
- f_status_t f_type_uint64s_append(const f_uint64s_t source, f_uint64s_t *destination) {
+#ifndef _di_f_uint64s_append_
+ f_status_t f_uint64s_append(const f_uint64s_t source, f_uint64s_t *destination) {
#ifndef _di_level_0_parameter_checking_
if (!destination) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
if (!source.used) return F_data_not;
- return private_f_type_uint64s_append(source, destination);
+ return private_f_uint64s_append(source, destination);
}
-#endif // _di_f_type_uint64s_append_
+#endif // _di_f_uint64s_append_
-#ifndef _di_f_type_uint64s_decimate_by_
- f_status_t f_type_uint64s_decimate_by(const f_array_length_t amount, f_uint64s_t *uint64s) {
+#ifndef _di_f_uint64s_decimate_by_
+ f_status_t f_uint64s_decimate_by(const f_array_length_t amount, f_uint64s_t *uint64s) {
#ifndef _di_level_0_parameter_checking_
if (!amount) return F_status_set_error(F_parameter);
if (!uint64s) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
if (uint64s->size - amount > 0) {
- return private_f_type_uint64s_adjust(uint64s->size - amount, uint64s);
+ return private_f_uint64s_adjust(uint64s->size - amount, uint64s);
}
- return private_f_type_uint64s_adjust(0, uint64s);
+ return private_f_uint64s_adjust(0, uint64s);
}
-#endif // _di_f_type_uint64s_decimate_by_
+#endif // _di_f_uint64s_decimate_by_
-#ifndef _di_f_type_uint64s_decrease_by_
- f_status_t f_type_uint64s_decrease_by(const f_array_length_t amount, f_uint64s_t *uint64s) {
+#ifndef _di_f_uint64s_decrease_by_
+ f_status_t f_uint64s_decrease_by(const f_array_length_t amount, f_uint64s_t *uint64s) {
#ifndef _di_level_0_parameter_checking_
if (!amount) return F_status_set_error(F_parameter);
if (!uint64s) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
if (uint64s->size - amount > 0) {
- return private_f_type_uint64s_resize(uint64s->size - amount, uint64s);
+ return private_f_uint64s_resize(uint64s->size - amount, uint64s);
}
- return private_f_type_uint64s_resize(0, uint64s);
+ return private_f_uint64s_resize(0, uint64s);
}
-#endif // _di_f_type_uint64s_decrease_by_
+#endif // _di_f_uint64s_decrease_by_
-#ifndef _di_f_type_uint64s_increase_
- f_status_t f_type_uint64s_increase(const uint16_t step, f_uint64s_t *uint64s) {
+#ifndef _di_f_uint64s_increase_
+ f_status_t f_uint64s_increase(const uint16_t step, f_uint64s_t *uint64s) {
#ifndef _di_level_0_parameter_checking_
if (!step) return F_status_set_error(F_parameter);
if (!uint64s) return F_status_set_error(F_parameter);
size = F_array_length_t_size_d;
}
- return private_f_type_uint64s_resize(size, uint64s);
+ return private_f_uint64s_resize(size, uint64s);
}
return F_data_not;
}
-#endif // _di_f_type_uint64s_increase_
+#endif // _di_f_uint64s_increase_
-#ifndef _di_f_type_uint64s_increase_by_
- f_status_t f_type_uint64s_increase_by(const f_array_length_t amount, f_uint64s_t *uint64s) {
+#ifndef _di_f_uint64s_increase_by_
+ f_status_t f_uint64s_increase_by(const f_array_length_t amount, f_uint64s_t *uint64s) {
#ifndef _di_level_0_parameter_checking_
if (!amount) return F_status_set_error(F_parameter);
if (!uint64s) return F_status_set_error(F_parameter);
return F_status_set_error(F_array_too_large);
}
- return private_f_type_uint64s_resize(uint64s->used + amount, uint64s);
+ return private_f_uint64s_resize(uint64s->used + amount, uint64s);
}
return F_data_not;
}
-#endif // _di_f_type_uint64s_increase_by_
+#endif // _di_f_uint64s_increase_by_
-#ifndef _di_f_type_uint64s_resize_
- f_status_t f_type_uint64s_resize(const f_array_length_t length, f_uint64s_t *uint64s) {
+#ifndef _di_f_uint64s_resize_
+ f_status_t f_uint64s_resize(const f_array_length_t length, f_uint64s_t *uint64s) {
#ifndef _di_level_0_parameter_checking_
if (!uint64s) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
- return private_f_type_uint64s_resize(length, uint64s);
+ return private_f_uint64s_resize(length, uint64s);
}
-#endif // _di_f_type_uint64s_resize_
+#endif // _di_f_uint64s_resize_
-#ifndef _di_f_type_uint64ss_adjust_
- f_status_t f_type_uint64ss_adjust(const f_array_length_t length, f_uint64ss_t *uint64ss) {
+#ifndef _di_f_uint64ss_adjust_
+ f_status_t f_uint64ss_adjust(const f_array_length_t length, f_uint64ss_t *uint64ss) {
#ifndef _di_level_0_parameter_checking_
if (!uint64ss) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
- return private_f_type_uint64ss_adjust(length, uint64ss);
+ return private_f_uint64ss_adjust(length, uint64ss);
}
-#endif // _di_f_type_uint64ss_adjust_
+#endif // _di_f_uint64ss_adjust_
-#ifndef _di_f_type_uint64ss_append_
- f_status_t f_type_uint64ss_append(const f_uint64ss_t source, f_uint64ss_t *destination) {
+#ifndef _di_f_uint64ss_append_
+ f_status_t f_uint64ss_append(const f_uint64ss_t source, f_uint64ss_t *destination) {
#ifndef _di_level_0_parameter_checking_
if (!destination) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
f_status_t status = F_none;
if (destination->used + source.used > destination->size) {
- status = private_f_type_uint64ss_resize(destination->used + source.used, destination);
+ status = private_f_uint64ss_resize(destination->used + source.used, destination);
if (F_status_is_error(status)) return status;
}
for (f_array_length_t i = 0; i < source.used; ++i, ++destination->used) {
- status = private_f_type_uint64s_append(source.array[i], &destination->array[destination->used]);
+ status = private_f_uint64s_append(source.array[i], &destination->array[destination->used]);
if (F_status_is_error(status)) return status;
} // for
return F_none;
}
-#endif // _di_f_type_uint64ss_append_
+#endif // _di_f_uint64ss_append_
-#ifndef _di_f_type_uint64ss_decimate_by_
- f_status_t f_type_uint64ss_decimate_by(const f_array_length_t amount, f_uint64ss_t *uint64ss) {
+#ifndef _di_f_uint64ss_decimate_by_
+ f_status_t f_uint64ss_decimate_by(const f_array_length_t amount, f_uint64ss_t *uint64ss) {
#ifndef _di_level_0_parameter_checking_
if (!amount) return F_status_set_error(F_parameter);
if (!uint64ss) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
if (uint64ss->size - amount > 0) {
- return private_f_type_uint64ss_adjust(uint64ss->size - amount, uint64ss);
+ return private_f_uint64ss_adjust(uint64ss->size - amount, uint64ss);
}
- return private_f_type_uint64ss_adjust(0, uint64ss);
+ return private_f_uint64ss_adjust(0, uint64ss);
}
-#endif // _di_f_type_uint64ss_decimate_by_
+#endif // _di_f_uint64ss_decimate_by_
-#ifndef _di_f_type_uint64ss_decrease_by_
- f_status_t f_type_uint64ss_decrease_by(const f_array_length_t amount, f_uint64ss_t *uint64ss) {
+#ifndef _di_f_uint64ss_decrease_by_
+ f_status_t f_uint64ss_decrease_by(const f_array_length_t amount, f_uint64ss_t *uint64ss) {
#ifndef _di_level_0_parameter_checking_
if (!amount) return F_status_set_error(F_parameter);
if (!uint64ss) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
if (uint64ss->size - amount > 0) {
- return private_f_type_uint64ss_resize(uint64ss->size - amount, uint64ss);
+ return private_f_uint64ss_resize(uint64ss->size - amount, uint64ss);
}
- return private_f_type_uint64ss_resize(0, uint64ss);
+ return private_f_uint64ss_resize(0, uint64ss);
}
-#endif // _di_f_type_uint64ss_decrease_by_
+#endif // _di_f_uint64ss_decrease_by_
-#ifndef _di_f_type_uint64ss_increase_
- f_status_t f_type_uint64ss_increase(const uint16_t step, f_uint64ss_t *uint64ss) {
+#ifndef _di_f_uint64ss_increase_
+ f_status_t f_uint64ss_increase(const uint16_t step, f_uint64ss_t *uint64ss) {
#ifndef _di_level_0_parameter_checking_
if (!step) return F_status_set_error(F_parameter);
if (!uint64ss) return F_status_set_error(F_parameter);
size = F_array_length_t_size_d;
}
- return private_f_type_uint64ss_resize(size, uint64ss);
+ return private_f_uint64ss_resize(size, uint64ss);
}
return F_data_not;
}
-#endif // _di_f_type_uint64ss_increase_
+#endif // _di_f_uint64ss_increase_
-#ifndef _di_f_type_uint64ss_increase_by_
- f_status_t f_type_uint64ss_increase_by(const f_array_length_t amount, f_uint64ss_t *uint64ss) {
+#ifndef _di_f_uint64ss_increase_by_
+ f_status_t f_uint64ss_increase_by(const f_array_length_t amount, f_uint64ss_t *uint64ss) {
#ifndef _di_level_0_parameter_checking_
if (!amount) return F_status_set_error(F_parameter);
if (!uint64ss) return F_status_set_error(F_parameter);
return F_status_set_error(F_array_too_large);
}
- return private_f_type_uint64ss_resize(uint64ss->used + amount, uint64ss);
+ return private_f_uint64ss_resize(uint64ss->used + amount, uint64ss);
}
return F_data_not;
}
-#endif // _di_f_type_uint64ss_increase_by_
+#endif // _di_f_uint64ss_increase_by_
-#ifndef _di_f_type_uint64ss_resize_
- f_status_t f_type_uint64ss_resize(const f_array_length_t length, f_uint64ss_t *uint64ss) {
+#ifndef _di_f_uint64ss_resize_
+ f_status_t f_uint64ss_resize(const f_array_length_t length, f_uint64ss_t *uint64ss) {
#ifndef _di_level_0_parameter_checking_
if (!uint64ss) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
- return private_f_type_uint64ss_resize(length, uint64ss);
+ return private_f_uint64ss_resize(length, uint64ss);
}
-#endif // _di_f_type_uint64ss_resize_
+#endif // _di_f_uint64ss_resize_
#ifdef __cplusplus
} // extern "C"
*
* Errors (with error bit) from: f_memory_adjust().
*/
-#ifndef _di_f_type_int64s_adjust_
- extern f_status_t f_type_int64s_adjust(const f_array_length_t length, f_int64s_t *int64s);
-#endif // _di_f_type_int64s_adjust_
+#ifndef _di_f_int64s_adjust_
+ extern f_status_t f_int64s_adjust(const f_array_length_t length, f_int64s_t *int64s);
+#endif // _di_f_int64s_adjust_
/**
* Append the source int64s onto the destination.
*
* Errors (with error bit) from: f_memory_resize().
*/
-#ifndef _di_f_type_int64s_append_
- extern f_status_t f_type_int64s_append(const f_int64s_t source, f_int64s_t *destination);
-#endif // _di_f_type_int64s_append_
+#ifndef _di_f_int64s_append_
+ extern f_status_t f_int64s_append(const f_int64s_t source, f_int64s_t *destination);
+#endif // _di_f_int64s_append_
/**
* Resize the int64s array to a smaller size.
*
* Errors (with error bit) from: f_memory_adjust().
*/
-#ifndef _di_f_type_int64s_decimate_by_
- extern f_status_t f_type_int64s_decimate_by(const f_array_length_t amount, f_int64s_t *int64s);
-#endif // _di_f_type_int64s_decimate_by_
+#ifndef _di_f_int64s_decimate_by_
+ extern f_status_t f_int64s_decimate_by(const f_array_length_t amount, f_int64s_t *int64s);
+#endif // _di_f_int64s_decimate_by_
/**
* Resize the int64s array to a smaller size.
*
* Errors (with error bit) from: f_memory_resize().
*/
-#ifndef _di_f_type_int64s_decrease_by_
- extern f_status_t f_type_int64s_decrease_by(const f_array_length_t amount, f_int64s_t *int64s);
-#endif // _di_f_type_int64s_decrease_by_
+#ifndef _di_f_int64s_decrease_by_
+ extern f_status_t f_int64s_decrease_by(const f_array_length_t amount, f_int64s_t *int64s);
+#endif // _di_f_int64s_decrease_by_
/**
* Increase the size of the int64s array, but only if necesary.
*
* Errors (with error bit) from: f_memory_resize().
*/
-#ifndef _di_f_type_int64s_increase_
- extern f_status_t f_type_int64s_increase(const uint16_t step, f_int64s_t *int64s);
-#endif // _di_f_type_int64s_increase_
+#ifndef _di_f_int64s_increase_
+ extern f_status_t f_int64s_increase(const uint16_t step, f_int64s_t *int64s);
+#endif // _di_f_int64s_increase_
/**
* Resize the int64s array to a larger size.
*
* Errors (with error bit) from: f_memory_resize().
*/
-#ifndef _di_f_type_int64s_increase_by_
- extern f_status_t f_type_int64s_increase_by(const f_array_length_t amount, f_int64s_t *int64s);
-#endif // _di_f_type_int64s_increase_by_
+#ifndef _di_f_int64s_increase_by_
+ extern f_status_t f_int64s_increase_by(const f_array_length_t amount, f_int64s_t *int64s);
+#endif // _di_f_int64s_increase_by_
/**
* Resize the int64s array.
*
* Errors (with error bit) from: f_memory_resize().
*/
-#ifndef _di_f_type_int64s_resize_
- extern f_status_t f_type_int64s_resize(const f_array_length_t length, f_int64s_t *int64s);
-#endif // _di_f_type_int64s_resize_
+#ifndef _di_f_int64s_resize_
+ extern f_status_t f_int64s_resize(const f_array_length_t length, f_int64s_t *int64s);
+#endif // _di_f_int64s_resize_
/**
* Resize the int64ss array.
* Errors (with error bit) from: f_memory_adjust().
* Errors (with error bit) from: f_memory_destroy().
*/
-#ifndef _di_f_type_int64ss_adjust_
- extern f_status_t f_type_int64ss_adjust(const f_array_length_t length, f_int64ss_t *int64ss);
-#endif // _di_f_type_int64ss_adjust_
+#ifndef _di_f_int64ss_adjust_
+ extern f_status_t f_int64ss_adjust(const f_array_length_t length, f_int64ss_t *int64ss);
+#endif // _di_f_int64ss_adjust_
/**
* Append the source int64ss onto the destination.
*
* Errors (with error bit) from: f_memory_resize().
*/
-#ifndef _di_f_type_int64ss_append_
- extern f_status_t f_type_int64ss_append(const f_int64ss_t source, f_int64ss_t *destination);
-#endif // _di_f_type_int64ss_append_
+#ifndef _di_f_int64ss_append_
+ extern f_status_t f_int64ss_append(const f_int64ss_t source, f_int64ss_t *destination);
+#endif // _di_f_int64ss_append_
/**
* Resize the int64ss array.
* Errors (with error bit) from: f_memory_adjust().
* Errors (with error bit) from: f_memory_destroy().
*/
-#ifndef _di_f_type_int64ss_adjust_
- extern f_status_t f_type_int64ss_adjust(const f_array_length_t length, f_int64ss_t *int64ss);
-#endif // _di_f_type_int64ss_adjust_
+#ifndef _di_f_int64ss_adjust_
+ extern f_status_t f_int64ss_adjust(const f_array_length_t length, f_int64ss_t *int64ss);
+#endif // _di_f_int64ss_adjust_
/**
* Resize the int64ss array to a smaller size.
* Errors (with error bit) from: f_memory_adjust().
* Errors (with error bit) from: f_memory_destroy().
*/
-#ifndef _di_f_type_int64ss_decimate_by_
- extern f_status_t f_type_int64ss_decimate_by(const f_array_length_t amount, f_int64ss_t *int64ss);
-#endif // _di_f_type_int64ss_decimate_by_
+#ifndef _di_f_int64ss_decimate_by_
+ extern f_status_t f_int64ss_decimate_by(const f_array_length_t amount, f_int64ss_t *int64ss);
+#endif // _di_f_int64ss_decimate_by_
/**
* Resize the int64ss array to a smaller size.
* Errors (with error bit) from: f_memory_delete().
* Errors (with error bit) from: f_memory_resize().
*/
-#ifndef _di_f_type_int64ss_decrease_by_
- extern f_status_t f_type_int64ss_decrease_by(const f_array_length_t amount, f_int64ss_t *int64ss);
-#endif // _di_f_type_int64ss_decrease_by_
+#ifndef _di_f_int64ss_decrease_by_
+ extern f_status_t f_int64ss_decrease_by(const f_array_length_t amount, f_int64ss_t *int64ss);
+#endif // _di_f_int64ss_decrease_by_
/**
* Increase the size of the int64ss array, but only if necessary.
*
* Errors (with error bit) from: f_memory_resize().
*/
-#ifndef _di_f_type_int64ss_increase_
- extern f_status_t f_type_int64ss_increase(const uint16_t step, f_int64ss_t *int64ss);
-#endif // _di_f_type_int64ss_increase_
+#ifndef _di_f_int64ss_increase_
+ extern f_status_t f_int64ss_increase(const uint16_t step, f_int64ss_t *int64ss);
+#endif // _di_f_int64ss_increase_
/**
* Resize the int64ss array to a larger size.
*
* Errors (with error bit) from: f_memory_resize().
*/
-#ifndef _di_f_type_int64ss_increase_by_
- extern f_status_t f_type_int64ss_increase_by(const f_array_length_t amount, f_int64ss_t *int64ss);
-#endif // _di_f_type_int64ss_increase_by_
+#ifndef _di_f_int64ss_increase_by_
+ extern f_status_t f_int64ss_increase_by(const f_array_length_t amount, f_int64ss_t *int64ss);
+#endif // _di_f_int64ss_increase_by_
/**
* Resize the int64ss array.
* Errors (with error bit) from: f_memory_delete().
* Errors (with error bit) from: f_memory_resize().
*/
-#ifndef _di_f_type_int64ss_resize_
- extern f_status_t f_type_int64ss_resize(const f_array_length_t length, f_int64ss_t *int64ss);
-#endif // _di_f_type_int64ss_resize_
+#ifndef _di_f_int64ss_resize_
+ extern f_status_t f_int64ss_resize(const f_array_length_t length, f_int64ss_t *int64ss);
+#endif // _di_f_int64ss_resize_
/**
* Resize the string uint64s array.
*
* Errors (with error bit) from: f_memory_adjust().
*/
-#ifndef _di_f_type_uint64s_adjust_
- extern f_status_t f_type_uint64s_adjust(const f_array_length_t length, f_uint64s_t *uint64s);
-#endif // _di_f_type_uint64s_adjust_
+#ifndef _di_f_uint64s_adjust_
+ extern f_status_t f_uint64s_adjust(const f_array_length_t length, f_uint64s_t *uint64s);
+#endif // _di_f_uint64s_adjust_
/**
* Append the source uint64s onto the destination.
*
* Errors (with error bit) from: f_memory_resize().
*/
-#ifndef _di_f_type_uint64s_append_
- extern f_status_t f_type_uint64s_append(const f_uint64s_t source, f_uint64s_t *destination);
-#endif // _di_f_type_uint64s_append_
+#ifndef _di_f_uint64s_append_
+ extern f_status_t f_uint64s_append(const f_uint64s_t source, f_uint64s_t *destination);
+#endif // _di_f_uint64s_append_
/**
* Resize the string uint64s array to a smaller size.
*
* Errors (with error bit) from: f_memory_adjust().
*/
-#ifndef _di_f_type_uint64s_decimate_by_
- extern f_status_t f_type_uint64s_decimate_by(const f_array_length_t amount, f_uint64s_t *uint64s);
-#endif // _di_f_type_uint64s_decimate_by_
+#ifndef _di_f_uint64s_decimate_by_
+ extern f_status_t f_uint64s_decimate_by(const f_array_length_t amount, f_uint64s_t *uint64s);
+#endif // _di_f_uint64s_decimate_by_
/**
* Resize the string uint64s array to a smaller size.
*
* Errors (with error bit) from: f_memory_resize().
*/
-#ifndef _di_f_type_uint64s_decrease_by_
- extern f_status_t f_type_uint64s_decrease_by(const f_array_length_t amount, f_uint64s_t *uint64s);
-#endif // _di_f_type_uint64s_decrease_by_
+#ifndef _di_f_uint64s_decrease_by_
+ extern f_status_t f_uint64s_decrease_by(const f_array_length_t amount, f_uint64s_t *uint64s);
+#endif // _di_f_uint64s_decrease_by_
/**
* Increase the size of the string uint64s array, but only if necesary.
*
* Errors (with error bit) from: f_memory_resize().
*/
-#ifndef _di_f_type_uint64s_increase_
- extern f_status_t f_type_uint64s_increase(const uint16_t step, f_uint64s_t *uint64s);
-#endif // _di_f_type_uint64s_increase_
+#ifndef _di_f_uint64s_increase_
+ extern f_status_t f_uint64s_increase(const uint16_t step, f_uint64s_t *uint64s);
+#endif // _di_f_uint64s_increase_
/**
* Resize the string uint64s array to a larger size.
*
* Errors (with error bit) from: f_memory_resize().
*/
-#ifndef _di_f_type_uint64s_increase_by_
- extern f_status_t f_type_uint64s_increase_by(const f_array_length_t amount, f_uint64s_t *uint64s);
-#endif // _di_f_type_uint64s_increase_by_
+#ifndef _di_f_uint64s_increase_by_
+ extern f_status_t f_uint64s_increase_by(const f_array_length_t amount, f_uint64s_t *uint64s);
+#endif // _di_f_uint64s_increase_by_
/**
* Resize the string uint64s array.
*
* Errors (with error bit) from: f_memory_resize().
*/
-#ifndef _di_f_type_uint64s_resize_
- extern f_status_t f_type_uint64s_resize(const f_array_length_t length, f_uint64s_t *uint64s);
-#endif // _di_f_type_uint64s_resize_
+#ifndef _di_f_uint64s_resize_
+ extern f_status_t f_uint64s_resize(const f_array_length_t length, f_uint64s_t *uint64s);
+#endif // _di_f_uint64s_resize_
/**
* Resize the string uint64ss array.
* Errors (with error bit) from: f_memory_adjust().
* Errors (with error bit) from: f_memory_destroy().
*/
-#ifndef _di_f_type_uint64ss_adjust_
- extern f_status_t f_type_uint64ss_adjust(const f_array_length_t length, f_uint64ss_t *uint64ss);
-#endif // _di_f_type_uint64ss_adjust_
+#ifndef _di_f_uint64ss_adjust_
+ extern f_status_t f_uint64ss_adjust(const f_array_length_t length, f_uint64ss_t *uint64ss);
+#endif // _di_f_uint64ss_adjust_
/**
* Append the source uint64ss onto the destination.
*
* Errors (with error bit) from: f_memory_resize().
*/
-#ifndef _di_f_type_uint64ss_append_
- extern f_status_t f_type_uint64ss_append(const f_uint64ss_t source, f_uint64ss_t *destination);
-#endif // _di_f_type_uint64ss_append_
+#ifndef _di_f_uint64ss_append_
+ extern f_status_t f_uint64ss_append(const f_uint64ss_t source, f_uint64ss_t *destination);
+#endif // _di_f_uint64ss_append_
/**
* Resize the string uint64ss array.
* Errors (with error bit) from: f_memory_adjust().
* Errors (with error bit) from: f_memory_destroy().
*/
-#ifndef _di_f_type_uint64ss_adjust_
- extern f_status_t f_type_uint64ss_adjust(const f_array_length_t length, f_uint64ss_t *uint64ss);
-#endif // _di_f_type_uint64ss_adjust_
+#ifndef _di_f_uint64ss_adjust_
+ extern f_status_t f_uint64ss_adjust(const f_array_length_t length, f_uint64ss_t *uint64ss);
+#endif // _di_f_uint64ss_adjust_
/**
* Resize the string uint64ss array to a smaller size.
* Errors (with error bit) from: f_memory_adjust().
* Errors (with error bit) from: f_memory_destroy().
*/
-#ifndef _di_f_type_uint64ss_decimate_by_
- extern f_status_t f_type_uint64ss_decimate_by(const f_array_length_t amount, f_uint64ss_t *uint64ss);
-#endif // _di_f_type_uint64ss_decimate_by_
+#ifndef _di_f_uint64ss_decimate_by_
+ extern f_status_t f_uint64ss_decimate_by(const f_array_length_t amount, f_uint64ss_t *uint64ss);
+#endif // _di_f_uint64ss_decimate_by_
/**
* Resize the string uint64ss array to a smaller size.
* Errors (with error bit) from: f_memory_delete().
* Errors (with error bit) from: f_memory_resize().
*/
-#ifndef _di_f_type_uint64ss_decrease_by_
- extern f_status_t f_type_uint64ss_decrease_by(const f_array_length_t amount, f_uint64ss_t *uint64ss);
-#endif // _di_f_type_uint64ss_decrease_by_
+#ifndef _di_f_uint64ss_decrease_by_
+ extern f_status_t f_uint64ss_decrease_by(const f_array_length_t amount, f_uint64ss_t *uint64ss);
+#endif // _di_f_uint64ss_decrease_by_
/**
* Increase the size of the string uint64ss array, but only if necessary.
*
* Errors (with error bit) from: f_memory_resize().
*/
-#ifndef _di_f_type_uint64ss_increase_
- extern f_status_t f_type_uint64ss_increase(const uint16_t step, f_uint64ss_t *uint64ss);
-#endif // _di_f_type_uint64ss_increase_
+#ifndef _di_f_uint64ss_increase_
+ extern f_status_t f_uint64ss_increase(const uint16_t step, f_uint64ss_t *uint64ss);
+#endif // _di_f_uint64ss_increase_
/**
* Resize the string uint64ss array to a larger size.
*
* Errors (with error bit) from: f_memory_resize().
*/
-#ifndef _di_f_type_uint64ss_increase_by_
- extern f_status_t f_type_uint64ss_increase_by(const f_array_length_t amount, f_uint64ss_t *uint64ss);
-#endif // _di_f_type_uint64ss_increase_by_
+#ifndef _di_f_uint64ss_increase_by_
+ extern f_status_t f_uint64ss_increase_by(const f_array_length_t amount, f_uint64ss_t *uint64ss);
+#endif // _di_f_uint64ss_increase_by_
/**
* Resize the string uint64ss array.
* Errors (with error bit) from: f_memory_delete().
* Errors (with error bit) from: f_memory_resize().
*/
-#ifndef _di_f_type_uint64ss_resize_
- extern f_status_t f_type_uint64ss_resize(const f_array_length_t length, f_uint64ss_t *uint64ss);
-#endif // _di_f_type_uint64ss_resize_
+#ifndef _di_f_uint64ss_resize_
+ extern f_status_t f_uint64ss_resize(const f_array_length_t length, f_uint64ss_t *uint64ss);
+#endif // _di_f_uint64ss_resize_
#ifdef __cplusplus
} // extern "C"
extern "C" {
#endif
-#ifndef _di_f_type_int8s_adjust_
- f_status_t f_type_int8s_adjust(const f_array_length_t length, f_int8s_t *int8s) {
+#ifndef _di_f_int8s_adjust_
+ f_status_t f_int8s_adjust(const f_array_length_t length, f_int8s_t *int8s) {
#ifndef _di_level_0_parameter_checking_
if (!int8s) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
- return private_f_type_int8s_adjust(length, int8s);
+ return private_f_int8s_adjust(length, int8s);
}
-#endif // _di_f_type_int8s_adjust_
+#endif // _di_f_int8s_adjust_
-#ifndef _di_f_type_int8s_append_
- f_status_t f_type_int8s_append(const f_int8s_t source, f_int8s_t *destination) {
+#ifndef _di_f_int8s_append_
+ f_status_t f_int8s_append(const f_int8s_t source, f_int8s_t *destination) {
#ifndef _di_level_0_parameter_checking_
if (!destination) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
if (!source.used) return F_data_not;
- return private_f_type_int8s_append(source, destination);
+ return private_f_int8s_append(source, destination);
}
-#endif // _di_f_type_int8s_append_
+#endif // _di_f_int8s_append_
-#ifndef _di_f_type_int8s_decimate_by_
- f_status_t f_type_int8s_decimate_by(const f_array_length_t amount, f_int8s_t *int8s) {
+#ifndef _di_f_int8s_decimate_by_
+ f_status_t f_int8s_decimate_by(const f_array_length_t amount, f_int8s_t *int8s) {
#ifndef _di_level_0_parameter_checking_
if (!amount) return F_status_set_error(F_parameter);
if (!int8s) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
if (int8s->size - amount > 0) {
- return private_f_type_int8s_adjust(int8s->size - amount, int8s);
+ return private_f_int8s_adjust(int8s->size - amount, int8s);
}
- return private_f_type_int8s_adjust(0, int8s);
+ return private_f_int8s_adjust(0, int8s);
}
-#endif // _di_f_type_int8s_decimate_by_
+#endif // _di_f_int8s_decimate_by_
-#ifndef _di_f_type_int8s_decrease_by_
- f_status_t f_type_int8s_decrease_by(const f_array_length_t amount, f_int8s_t *int8s) {
+#ifndef _di_f_int8s_decrease_by_
+ f_status_t f_int8s_decrease_by(const f_array_length_t amount, f_int8s_t *int8s) {
#ifndef _di_level_0_parameter_checking_
if (!amount) return F_status_set_error(F_parameter);
if (!int8s) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
if (int8s->size - amount > 0) {
- return private_f_type_int8s_resize(int8s->size - amount, int8s);
+ return private_f_int8s_resize(int8s->size - amount, int8s);
}
- return private_f_type_int8s_resize(0, int8s);
+ return private_f_int8s_resize(0, int8s);
}
-#endif // _di_f_type_int8s_decrease_by_
+#endif // _di_f_int8s_decrease_by_
-#ifndef _di_f_type_int8s_increase_
- f_status_t f_type_int8s_increase(const uint16_t step, f_int8s_t *int8s) {
+#ifndef _di_f_int8s_increase_
+ f_status_t f_int8s_increase(const uint16_t step, f_int8s_t *int8s) {
#ifndef _di_level_0_parameter_checking_
if (!step) return F_status_set_error(F_parameter);
if (!int8s) return F_status_set_error(F_parameter);
size = F_array_length_t_size_d;
}
- return private_f_type_int8s_resize(size, int8s);
+ return private_f_int8s_resize(size, int8s);
}
return F_data_not;
}
-#endif // _di_f_type_int8s_increase_
+#endif // _di_f_int8s_increase_
-#ifndef _di_f_type_int8s_increase_by_
- f_status_t f_type_int8s_increase_by(const f_array_length_t amount, f_int8s_t *int8s) {
+#ifndef _di_f_int8s_increase_by_
+ f_status_t f_int8s_increase_by(const f_array_length_t amount, f_int8s_t *int8s) {
#ifndef _di_level_0_parameter_checking_
if (!amount) return F_status_set_error(F_parameter);
if (!int8s) return F_status_set_error(F_parameter);
return F_status_set_error(F_array_too_large);
}
- return private_f_type_int8s_resize(int8s->used + amount, int8s);
+ return private_f_int8s_resize(int8s->used + amount, int8s);
}
return F_data_not;
}
-#endif // _di_f_type_int8s_increase_by_
+#endif // _di_f_int8s_increase_by_
-#ifndef _di_f_type_int8s_resize_
- f_status_t f_type_int8s_resize(const f_array_length_t length, f_int8s_t *int8s) {
+#ifndef _di_f_int8s_resize_
+ f_status_t f_int8s_resize(const f_array_length_t length, f_int8s_t *int8s) {
#ifndef _di_level_0_parameter_checking_
if (!int8s) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
- return private_f_type_int8s_resize(length, int8s);
+ return private_f_int8s_resize(length, int8s);
}
-#endif // _di_f_type_int8s_resize_
+#endif // _di_f_int8s_resize_
-#ifndef _di_f_type_int8ss_adjust_
- f_status_t f_type_int8ss_adjust(const f_array_length_t length, f_int8ss_t *int8ss) {
+#ifndef _di_f_int8ss_adjust_
+ f_status_t f_int8ss_adjust(const f_array_length_t length, f_int8ss_t *int8ss) {
#ifndef _di_level_0_parameter_checking_
if (!int8ss) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
- return private_f_type_int8ss_adjust(length, int8ss);
+ return private_f_int8ss_adjust(length, int8ss);
}
-#endif // _di_f_type_int8ss_adjust_
+#endif // _di_f_int8ss_adjust_
-#ifndef _di_f_type_int8ss_append_
- f_status_t f_type_int8ss_append(const f_int8ss_t source, f_int8ss_t *destination) {
+#ifndef _di_f_int8ss_append_
+ f_status_t f_int8ss_append(const f_int8ss_t source, f_int8ss_t *destination) {
#ifndef _di_level_0_parameter_checking_
if (!destination) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
f_status_t status = F_none;
if (destination->used + source.used > destination->size) {
- status = private_f_type_int8ss_resize(destination->used + source.used, destination);
+ status = private_f_int8ss_resize(destination->used + source.used, destination);
if (F_status_is_error(status)) return status;
}
for (f_array_length_t i = 0; i < source.used; ++i, ++destination->used) {
- status = private_f_type_int8s_append(source.array[i], &destination->array[destination->used]);
+ status = private_f_int8s_append(source.array[i], &destination->array[destination->used]);
if (F_status_is_error(status)) return status;
} // for
return F_none;
}
-#endif // _di_f_type_int8ss_append_
+#endif // _di_f_int8ss_append_
-#ifndef _di_f_type_int8ss_decimate_by_
- f_status_t f_type_int8ss_decimate_by(const f_array_length_t amount, f_int8ss_t *int8ss) {
+#ifndef _di_f_int8ss_decimate_by_
+ f_status_t f_int8ss_decimate_by(const f_array_length_t amount, f_int8ss_t *int8ss) {
#ifndef _di_level_0_parameter_checking_
if (!amount) return F_status_set_error(F_parameter);
if (!int8ss) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
if (int8ss->size - amount > 0) {
- return private_f_type_int8ss_adjust(int8ss->size - amount, int8ss);
+ return private_f_int8ss_adjust(int8ss->size - amount, int8ss);
}
- return private_f_type_int8ss_adjust(0, int8ss);
+ return private_f_int8ss_adjust(0, int8ss);
}
-#endif // _di_f_type_int8ss_decimate_by_
+#endif // _di_f_int8ss_decimate_by_
-#ifndef _di_f_type_int8ss_decrease_by_
- f_status_t f_type_int8ss_decrease_by(const f_array_length_t amount, f_int8ss_t *int8ss) {
+#ifndef _di_f_int8ss_decrease_by_
+ f_status_t f_int8ss_decrease_by(const f_array_length_t amount, f_int8ss_t *int8ss) {
#ifndef _di_level_0_parameter_checking_
if (!amount) return F_status_set_error(F_parameter);
if (!int8ss) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
if (int8ss->size - amount > 0) {
- return private_f_type_int8ss_resize(int8ss->size - amount, int8ss);
+ return private_f_int8ss_resize(int8ss->size - amount, int8ss);
}
- return private_f_type_int8ss_resize(0, int8ss);
+ return private_f_int8ss_resize(0, int8ss);
}
-#endif // _di_f_type_int8ss_decrease_by_
+#endif // _di_f_int8ss_decrease_by_
-#ifndef _di_f_type_int8ss_increase_
- f_status_t f_type_int8ss_increase(const uint16_t step, f_int8ss_t *int8ss) {
+#ifndef _di_f_int8ss_increase_
+ f_status_t f_int8ss_increase(const uint16_t step, f_int8ss_t *int8ss) {
#ifndef _di_level_0_parameter_checking_
if (!step) return F_status_set_error(F_parameter);
if (!int8ss) return F_status_set_error(F_parameter);
size = F_array_length_t_size_d;
}
- return private_f_type_int8ss_resize(size, int8ss);
+ return private_f_int8ss_resize(size, int8ss);
}
return F_data_not;
}
-#endif // _di_f_type_int8ss_increase_
+#endif // _di_f_int8ss_increase_
-#ifndef _di_f_type_int8ss_increase_by_
- f_status_t f_type_int8ss_increase_by(const f_array_length_t amount, f_int8ss_t *int8ss) {
+#ifndef _di_f_int8ss_increase_by_
+ f_status_t f_int8ss_increase_by(const f_array_length_t amount, f_int8ss_t *int8ss) {
#ifndef _di_level_0_parameter_checking_
if (!amount) return F_status_set_error(F_parameter);
if (!int8ss) return F_status_set_error(F_parameter);
return F_status_set_error(F_array_too_large);
}
- return private_f_type_int8ss_resize(int8ss->used + amount, int8ss);
+ return private_f_int8ss_resize(int8ss->used + amount, int8ss);
}
return F_data_not;
}
-#endif // _di_f_type_int8ss_increase_by_
+#endif // _di_f_int8ss_increase_by_
-#ifndef _di_f_type_int8ss_resize_
- f_status_t f_type_int8ss_resize(const f_array_length_t length, f_int8ss_t *int8ss) {
+#ifndef _di_f_int8ss_resize_
+ f_status_t f_int8ss_resize(const f_array_length_t length, f_int8ss_t *int8ss) {
#ifndef _di_level_0_parameter_checking_
if (!int8ss) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
- return private_f_type_int8ss_resize(length, int8ss);
+ return private_f_int8ss_resize(length, int8ss);
}
-#endif // _di_f_type_int8ss_resize_
+#endif // _di_f_int8ss_resize_
-#ifndef _di_f_type_uint8s_adjust_
- f_status_t f_type_uint8s_adjust(const f_array_length_t length, f_uint8s_t *uint8s) {
+#ifndef _di_f_uint8s_adjust_
+ f_status_t f_uint8s_adjust(const f_array_length_t length, f_uint8s_t *uint8s) {
#ifndef _di_level_0_parameter_checking_
if (!uint8s) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
- return private_f_type_uint8s_adjust(length, uint8s);
+ return private_f_uint8s_adjust(length, uint8s);
}
-#endif // _di_f_type_uint8s_adjust_
+#endif // _di_f_uint8s_adjust_
-#ifndef _di_f_type_uint8s_append_
- f_status_t f_type_uint8s_append(const f_uint8s_t source, f_uint8s_t *destination) {
+#ifndef _di_f_uint8s_append_
+ f_status_t f_uint8s_append(const f_uint8s_t source, f_uint8s_t *destination) {
#ifndef _di_level_0_parameter_checking_
if (!destination) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
if (!source.used) return F_data_not;
- return private_f_type_uint8s_append(source, destination);
+ return private_f_uint8s_append(source, destination);
}
-#endif // _di_f_type_uint8s_append_
+#endif // _di_f_uint8s_append_
-#ifndef _di_f_type_uint8s_decimate_by_
- f_status_t f_type_uint8s_decimate_by(const f_array_length_t amount, f_uint8s_t *uint8s) {
+#ifndef _di_f_uint8s_decimate_by_
+ f_status_t f_uint8s_decimate_by(const f_array_length_t amount, f_uint8s_t *uint8s) {
#ifndef _di_level_0_parameter_checking_
if (!amount) return F_status_set_error(F_parameter);
if (!uint8s) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
if (uint8s->size - amount > 0) {
- return private_f_type_uint8s_adjust(uint8s->size - amount, uint8s);
+ return private_f_uint8s_adjust(uint8s->size - amount, uint8s);
}
- return private_f_type_uint8s_adjust(0, uint8s);
+ return private_f_uint8s_adjust(0, uint8s);
}
-#endif // _di_f_type_uint8s_decimate_by_
+#endif // _di_f_uint8s_decimate_by_
-#ifndef _di_f_type_uint8s_decrease_by_
- f_status_t f_type_uint8s_decrease_by(const f_array_length_t amount, f_uint8s_t *uint8s) {
+#ifndef _di_f_uint8s_decrease_by_
+ f_status_t f_uint8s_decrease_by(const f_array_length_t amount, f_uint8s_t *uint8s) {
#ifndef _di_level_0_parameter_checking_
if (!amount) return F_status_set_error(F_parameter);
if (!uint8s) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
if (uint8s->size - amount > 0) {
- return private_f_type_uint8s_resize(uint8s->size - amount, uint8s);
+ return private_f_uint8s_resize(uint8s->size - amount, uint8s);
}
- return private_f_type_uint8s_resize(0, uint8s);
+ return private_f_uint8s_resize(0, uint8s);
}
-#endif // _di_f_type_uint8s_decrease_by_
+#endif // _di_f_uint8s_decrease_by_
-#ifndef _di_f_type_uint8s_increase_
- f_status_t f_type_uint8s_increase(const uint16_t step, f_uint8s_t *uint8s) {
+#ifndef _di_f_uint8s_increase_
+ f_status_t f_uint8s_increase(const uint16_t step, f_uint8s_t *uint8s) {
#ifndef _di_level_0_parameter_checking_
if (!step) return F_status_set_error(F_parameter);
if (!uint8s) return F_status_set_error(F_parameter);
size = F_array_length_t_size_d;
}
- return private_f_type_uint8s_resize(size, uint8s);
+ return private_f_uint8s_resize(size, uint8s);
}
return F_data_not;
}
-#endif // _di_f_type_uint8s_increase_
+#endif // _di_f_uint8s_increase_
-#ifndef _di_f_type_uint8s_increase_by_
- f_status_t f_type_uint8s_increase_by(const f_array_length_t amount, f_uint8s_t *uint8s) {
+#ifndef _di_f_uint8s_increase_by_
+ f_status_t f_uint8s_increase_by(const f_array_length_t amount, f_uint8s_t *uint8s) {
#ifndef _di_level_0_parameter_checking_
if (!amount) return F_status_set_error(F_parameter);
if (!uint8s) return F_status_set_error(F_parameter);
return F_status_set_error(F_array_too_large);
}
- return private_f_type_uint8s_resize(uint8s->used + amount, uint8s);
+ return private_f_uint8s_resize(uint8s->used + amount, uint8s);
}
return F_data_not;
}
-#endif // _di_f_type_uint8s_increase_by_
+#endif // _di_f_uint8s_increase_by_
-#ifndef _di_f_type_uint8s_resize_
- f_status_t f_type_uint8s_resize(const f_array_length_t length, f_uint8s_t *uint8s) {
+#ifndef _di_f_uint8s_resize_
+ f_status_t f_uint8s_resize(const f_array_length_t length, f_uint8s_t *uint8s) {
#ifndef _di_level_0_parameter_checking_
if (!uint8s) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
- return private_f_type_uint8s_resize(length, uint8s);
+ return private_f_uint8s_resize(length, uint8s);
}
-#endif // _di_f_type_uint8s_resize_
+#endif // _di_f_uint8s_resize_
-#ifndef _di_f_type_uint8ss_adjust_
- f_status_t f_type_uint8ss_adjust(const f_array_length_t length, f_uint8ss_t *uint8ss) {
+#ifndef _di_f_uint8ss_adjust_
+ f_status_t f_uint8ss_adjust(const f_array_length_t length, f_uint8ss_t *uint8ss) {
#ifndef _di_level_0_parameter_checking_
if (!uint8ss) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
- return private_f_type_uint8ss_adjust(length, uint8ss);
+ return private_f_uint8ss_adjust(length, uint8ss);
}
-#endif // _di_f_type_uint8ss_adjust_
+#endif // _di_f_uint8ss_adjust_
-#ifndef _di_f_type_uint8ss_append_
- f_status_t f_type_uint8ss_append(const f_uint8ss_t source, f_uint8ss_t *destination) {
+#ifndef _di_f_uint8ss_append_
+ f_status_t f_uint8ss_append(const f_uint8ss_t source, f_uint8ss_t *destination) {
#ifndef _di_level_0_parameter_checking_
if (!destination) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
f_status_t status = F_none;
if (destination->used + source.used > destination->size) {
- status = private_f_type_uint8ss_resize(destination->used + source.used, destination);
+ status = private_f_uint8ss_resize(destination->used + source.used, destination);
if (F_status_is_error(status)) return status;
}
for (f_array_length_t i = 0; i < source.used; ++i, ++destination->used) {
- status = private_f_type_uint8s_append(source.array[i], &destination->array[destination->used]);
+ status = private_f_uint8s_append(source.array[i], &destination->array[destination->used]);
if (F_status_is_error(status)) return status;
} // for
return F_none;
}
-#endif // _di_f_type_uint8ss_append_
+#endif // _di_f_uint8ss_append_
-#ifndef _di_f_type_uint8ss_decimate_by_
- f_status_t f_type_uint8ss_decimate_by(const f_array_length_t amount, f_uint8ss_t *uint8ss) {
+#ifndef _di_f_uint8ss_decimate_by_
+ f_status_t f_uint8ss_decimate_by(const f_array_length_t amount, f_uint8ss_t *uint8ss) {
#ifndef _di_level_0_parameter_checking_
if (!amount) return F_status_set_error(F_parameter);
if (!uint8ss) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
if (uint8ss->size - amount > 0) {
- return private_f_type_uint8ss_adjust(uint8ss->size - amount, uint8ss);
+ return private_f_uint8ss_adjust(uint8ss->size - amount, uint8ss);
}
- return private_f_type_uint8ss_adjust(0, uint8ss);
+ return private_f_uint8ss_adjust(0, uint8ss);
}
-#endif // _di_f_type_uint8ss_decimate_by_
+#endif // _di_f_uint8ss_decimate_by_
-#ifndef _di_f_type_uint8ss_decrease_by_
- f_status_t f_type_uint8ss_decrease_by(const f_array_length_t amount, f_uint8ss_t *uint8ss) {
+#ifndef _di_f_uint8ss_decrease_by_
+ f_status_t f_uint8ss_decrease_by(const f_array_length_t amount, f_uint8ss_t *uint8ss) {
#ifndef _di_level_0_parameter_checking_
if (!amount) return F_status_set_error(F_parameter);
if (!uint8ss) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
if (uint8ss->size - amount > 0) {
- return private_f_type_uint8ss_resize(uint8ss->size - amount, uint8ss);
+ return private_f_uint8ss_resize(uint8ss->size - amount, uint8ss);
}
- return private_f_type_uint8ss_resize(0, uint8ss);
+ return private_f_uint8ss_resize(0, uint8ss);
}
-#endif // _di_f_type_uint8ss_decrease_by_
+#endif // _di_f_uint8ss_decrease_by_
-#ifndef _di_f_type_uint8ss_increase_
- f_status_t f_type_uint8ss_increase(const uint16_t step, f_uint8ss_t *uint8ss) {
+#ifndef _di_f_uint8ss_increase_
+ f_status_t f_uint8ss_increase(const uint16_t step, f_uint8ss_t *uint8ss) {
#ifndef _di_level_0_parameter_checking_
if (!step) return F_status_set_error(F_parameter);
if (!uint8ss) return F_status_set_error(F_parameter);
size = F_array_length_t_size_d;
}
- return private_f_type_uint8ss_resize(size, uint8ss);
+ return private_f_uint8ss_resize(size, uint8ss);
}
return F_data_not;
}
-#endif // _di_f_type_uint8ss_increase_
+#endif // _di_f_uint8ss_increase_
-#ifndef _di_f_type_uint8ss_increase_by_
- f_status_t f_type_uint8ss_increase_by(const f_array_length_t amount, f_uint8ss_t *uint8ss) {
+#ifndef _di_f_uint8ss_increase_by_
+ f_status_t f_uint8ss_increase_by(const f_array_length_t amount, f_uint8ss_t *uint8ss) {
#ifndef _di_level_0_parameter_checking_
if (!amount) return F_status_set_error(F_parameter);
if (!uint8ss) return F_status_set_error(F_parameter);
return F_status_set_error(F_array_too_large);
}
- return private_f_type_uint8ss_resize(uint8ss->used + amount, uint8ss);
+ return private_f_uint8ss_resize(uint8ss->used + amount, uint8ss);
}
return F_data_not;
}
-#endif // _di_f_type_uint8ss_increase_by_
+#endif // _di_f_uint8ss_increase_by_
-#ifndef _di_f_type_uint8ss_resize_
- f_status_t f_type_uint8ss_resize(const f_array_length_t length, f_uint8ss_t *uint8ss) {
+#ifndef _di_f_uint8ss_resize_
+ f_status_t f_uint8ss_resize(const f_array_length_t length, f_uint8ss_t *uint8ss) {
#ifndef _di_level_0_parameter_checking_
if (!uint8ss) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
- return private_f_type_uint8ss_resize(length, uint8ss);
+ return private_f_uint8ss_resize(length, uint8ss);
}
-#endif // _di_f_type_uint8ss_resize_
+#endif // _di_f_uint8ss_resize_
#ifdef __cplusplus
} // extern "C"
*
* Errors (with error bit) from: f_memory_adjust().
*/
-#ifndef _di_f_type_int8s_adjust_
- extern f_status_t f_type_int8s_adjust(const f_array_length_t length, f_int8s_t *int8s);
-#endif // _di_f_type_int8s_adjust_
+#ifndef _di_f_int8s_adjust_
+ extern f_status_t f_int8s_adjust(const f_array_length_t length, f_int8s_t *int8s);
+#endif // _di_f_int8s_adjust_
/**
* Append the source int8s onto the destination.
*
* Errors (with error bit) from: f_memory_resize().
*/
-#ifndef _di_f_type_int8s_append_
- extern f_status_t f_type_int8s_append(const f_int8s_t source, f_int8s_t *destination);
-#endif // _di_f_type_int8s_append_
+#ifndef _di_f_int8s_append_
+ extern f_status_t f_int8s_append(const f_int8s_t source, f_int8s_t *destination);
+#endif // _di_f_int8s_append_
/**
* Resize the int8s array to a smaller size.
*
* Errors (with error bit) from: f_memory_adjust().
*/
-#ifndef _di_f_type_int8s_decimate_by_
- extern f_status_t f_type_int8s_decimate_by(const f_array_length_t amount, f_int8s_t *int8s);
-#endif // _di_f_type_int8s_decimate_by_
+#ifndef _di_f_int8s_decimate_by_
+ extern f_status_t f_int8s_decimate_by(const f_array_length_t amount, f_int8s_t *int8s);
+#endif // _di_f_int8s_decimate_by_
/**
* Resize the int8s array to a smaller size.
*
* Errors (with error bit) from: f_memory_resize().
*/
-#ifndef _di_f_type_int8s_decrease_by_
- extern f_status_t f_type_int8s_decrease_by(const f_array_length_t amount, f_int8s_t *int8s);
-#endif // _di_f_type_int8s_decrease_by_
+#ifndef _di_f_int8s_decrease_by_
+ extern f_status_t f_int8s_decrease_by(const f_array_length_t amount, f_int8s_t *int8s);
+#endif // _di_f_int8s_decrease_by_
/**
* Increase the size of the int8s array, but only if necesary.
*
* Errors (with error bit) from: f_memory_resize().
*/
-#ifndef _di_f_type_int8s_increase_
- extern f_status_t f_type_int8s_increase(const uint16_t step, f_int8s_t *int8s);
-#endif // _di_f_type_int8s_increase_
+#ifndef _di_f_int8s_increase_
+ extern f_status_t f_int8s_increase(const uint16_t step, f_int8s_t *int8s);
+#endif // _di_f_int8s_increase_
/**
* Resize the int8s array to a larger size.
*
* Errors (with error bit) from: f_memory_resize().
*/
-#ifndef _di_f_type_int8s_increase_by_
- extern f_status_t f_type_int8s_increase_by(const f_array_length_t amount, f_int8s_t *int8s);
-#endif // _di_f_type_int8s_increase_by_
+#ifndef _di_f_int8s_increase_by_
+ extern f_status_t f_int8s_increase_by(const f_array_length_t amount, f_int8s_t *int8s);
+#endif // _di_f_int8s_increase_by_
/**
* Resize the int8s array.
*
* Errors (with error bit) from: f_memory_resize().
*/
-#ifndef _di_f_type_int8s_resize_
- extern f_status_t f_type_int8s_resize(const f_array_length_t length, f_int8s_t *int8s);
-#endif // _di_f_type_int8s_resize_
+#ifndef _di_f_int8s_resize_
+ extern f_status_t f_int8s_resize(const f_array_length_t length, f_int8s_t *int8s);
+#endif // _di_f_int8s_resize_
/**
* Resize the int8ss array.
* Errors (with error bit) from: f_memory_adjust().
* Errors (with error bit) from: f_memory_destroy().
*/
-#ifndef _di_f_type_int8ss_adjust_
- extern f_status_t f_type_int8ss_adjust(const f_array_length_t length, f_int8ss_t *int8ss);
-#endif // _di_f_type_int8ss_adjust_
+#ifndef _di_f_int8ss_adjust_
+ extern f_status_t f_int8ss_adjust(const f_array_length_t length, f_int8ss_t *int8ss);
+#endif // _di_f_int8ss_adjust_
/**
* Append the source int8ss onto the destination.
*
* Errors (with error bit) from: f_memory_resize().
*/
-#ifndef _di_f_type_int8ss_append_
- extern f_status_t f_type_int8ss_append(const f_int8ss_t source, f_int8ss_t *destination);
-#endif // _di_f_type_int8ss_append_
+#ifndef _di_f_int8ss_append_
+ extern f_status_t f_int8ss_append(const f_int8ss_t source, f_int8ss_t *destination);
+#endif // _di_f_int8ss_append_
/**
* Resize the int8ss array.
* Errors (with error bit) from: f_memory_adjust().
* Errors (with error bit) from: f_memory_destroy().
*/
-#ifndef _di_f_type_int8ss_adjust_
- extern f_status_t f_type_int8ss_adjust(const f_array_length_t length, f_int8ss_t *int8ss);
-#endif // _di_f_type_int8ss_adjust_
+#ifndef _di_f_int8ss_adjust_
+ extern f_status_t f_int8ss_adjust(const f_array_length_t length, f_int8ss_t *int8ss);
+#endif // _di_f_int8ss_adjust_
/**
* Resize the int8ss array to a smaller size.
* Errors (with error bit) from: f_memory_adjust().
* Errors (with error bit) from: f_memory_destroy().
*/
-#ifndef _di_f_type_int8ss_decimate_by_
- extern f_status_t f_type_int8ss_decimate_by(const f_array_length_t amount, f_int8ss_t *int8ss);
-#endif // _di_f_type_int8ss_decimate_by_
+#ifndef _di_f_int8ss_decimate_by_
+ extern f_status_t f_int8ss_decimate_by(const f_array_length_t amount, f_int8ss_t *int8ss);
+#endif // _di_f_int8ss_decimate_by_
/**
* Resize the int8ss array to a smaller size.
* Errors (with error bit) from: f_memory_delete().
* Errors (with error bit) from: f_memory_resize().
*/
-#ifndef _di_f_type_int8ss_decrease_by_
- extern f_status_t f_type_int8ss_decrease_by(const f_array_length_t amount, f_int8ss_t *int8ss);
-#endif // _di_f_type_int8ss_decrease_by_
+#ifndef _di_f_int8ss_decrease_by_
+ extern f_status_t f_int8ss_decrease_by(const f_array_length_t amount, f_int8ss_t *int8ss);
+#endif // _di_f_int8ss_decrease_by_
/**
* Increase the size of the int8ss array, but only if necessary.
*
* Errors (with error bit) from: f_memory_resize().
*/
-#ifndef _di_f_type_int8ss_increase_
- extern f_status_t f_type_int8ss_increase(const uint16_t step, f_int8ss_t *int8ss);
-#endif // _di_f_type_int8ss_increase_
+#ifndef _di_f_int8ss_increase_
+ extern f_status_t f_int8ss_increase(const uint16_t step, f_int8ss_t *int8ss);
+#endif // _di_f_int8ss_increase_
/**
* Resize the int8ss array to a larger size.
*
* Errors (with error bit) from: f_memory_resize().
*/
-#ifndef _di_f_type_int8ss_increase_by_
- extern f_status_t f_type_int8ss_increase_by(const f_array_length_t amount, f_int8ss_t *int8ss);
-#endif // _di_f_type_int8ss_increase_by_
+#ifndef _di_f_int8ss_increase_by_
+ extern f_status_t f_int8ss_increase_by(const f_array_length_t amount, f_int8ss_t *int8ss);
+#endif // _di_f_int8ss_increase_by_
/**
* Resize the int8ss array.
* Errors (with error bit) from: f_memory_delete().
* Errors (with error bit) from: f_memory_resize().
*/
-#ifndef _di_f_type_int8ss_resize_
- extern f_status_t f_type_int8ss_resize(const f_array_length_t length, f_int8ss_t *int8ss);
-#endif // _di_f_type_int8ss_resize_
+#ifndef _di_f_int8ss_resize_
+ extern f_status_t f_int8ss_resize(const f_array_length_t length, f_int8ss_t *int8ss);
+#endif // _di_f_int8ss_resize_
/**
* Resize the string uint8s array.
*
* Errors (with error bit) from: f_memory_adjust().
*/
-#ifndef _di_f_type_uint8s_adjust_
- extern f_status_t f_type_uint8s_adjust(const f_array_length_t length, f_uint8s_t *uint8s);
-#endif // _di_f_type_uint8s_adjust_
+#ifndef _di_f_uint8s_adjust_
+ extern f_status_t f_uint8s_adjust(const f_array_length_t length, f_uint8s_t *uint8s);
+#endif // _di_f_uint8s_adjust_
/**
* Append the source uint8s onto the destination.
*
* Errors (with error bit) from: f_memory_resize().
*/
-#ifndef _di_f_type_uint8s_append_
- extern f_status_t f_type_uint8s_append(const f_uint8s_t source, f_uint8s_t *destination);
-#endif // _di_f_type_uint8s_append_
+#ifndef _di_f_uint8s_append_
+ extern f_status_t f_uint8s_append(const f_uint8s_t source, f_uint8s_t *destination);
+#endif // _di_f_uint8s_append_
/**
* Resize the string uint8s array to a smaller size.
*
* Errors (with error bit) from: f_memory_adjust().
*/
-#ifndef _di_f_type_uint8s_decimate_by_
- extern f_status_t f_type_uint8s_decimate_by(const f_array_length_t amount, f_uint8s_t *uint8s);
-#endif // _di_f_type_uint8s_decimate_by_
+#ifndef _di_f_uint8s_decimate_by_
+ extern f_status_t f_uint8s_decimate_by(const f_array_length_t amount, f_uint8s_t *uint8s);
+#endif // _di_f_uint8s_decimate_by_
/**
* Resize the string uint8s array to a smaller size.
*
* Errors (with error bit) from: f_memory_resize().
*/
-#ifndef _di_f_type_uint8s_decrease_by_
- extern f_status_t f_type_uint8s_decrease_by(const f_array_length_t amount, f_uint8s_t *uint8s);
-#endif // _di_f_type_uint8s_decrease_by_
+#ifndef _di_f_uint8s_decrease_by_
+ extern f_status_t f_uint8s_decrease_by(const f_array_length_t amount, f_uint8s_t *uint8s);
+#endif // _di_f_uint8s_decrease_by_
/**
* Increase the size of the string uint8s array, but only if necesary.
*
* Errors (with error bit) from: f_memory_resize().
*/
-#ifndef _di_f_type_uint8s_increase_
- extern f_status_t f_type_uint8s_increase(const uint16_t step, f_uint8s_t *uint8s);
-#endif // _di_f_type_uint8s_increase_
+#ifndef _di_f_uint8s_increase_
+ extern f_status_t f_uint8s_increase(const uint16_t step, f_uint8s_t *uint8s);
+#endif // _di_f_uint8s_increase_
/**
* Resize the string uint8s array to a larger size.
*
* Errors (with error bit) from: f_memory_resize().
*/
-#ifndef _di_f_type_uint8s_increase_by_
- extern f_status_t f_type_uint8s_increase_by(const f_array_length_t amount, f_uint8s_t *uint8s);
-#endif // _di_f_type_uint8s_increase_by_
+#ifndef _di_f_uint8s_increase_by_
+ extern f_status_t f_uint8s_increase_by(const f_array_length_t amount, f_uint8s_t *uint8s);
+#endif // _di_f_uint8s_increase_by_
/**
* Resize the string uint8s array.
*
* Errors (with error bit) from: f_memory_resize().
*/
-#ifndef _di_f_type_uint8s_resize_
- extern f_status_t f_type_uint8s_resize(const f_array_length_t length, f_uint8s_t *uint8s);
-#endif // _di_f_type_uint8s_resize_
+#ifndef _di_f_uint8s_resize_
+ extern f_status_t f_uint8s_resize(const f_array_length_t length, f_uint8s_t *uint8s);
+#endif // _di_f_uint8s_resize_
/**
* Resize the string uint8ss array.
* Errors (with error bit) from: f_memory_adjust().
* Errors (with error bit) from: f_memory_destroy().
*/
-#ifndef _di_f_type_uint8ss_adjust_
- extern f_status_t f_type_uint8ss_adjust(const f_array_length_t length, f_uint8ss_t *uint8ss);
-#endif // _di_f_type_uint8ss_adjust_
+#ifndef _di_f_uint8ss_adjust_
+ extern f_status_t f_uint8ss_adjust(const f_array_length_t length, f_uint8ss_t *uint8ss);
+#endif // _di_f_uint8ss_adjust_
/**
* Append the source uint8ss onto the destination.
*
* Errors (with error bit) from: f_memory_resize().
*/
-#ifndef _di_f_type_uint8ss_append_
- extern f_status_t f_type_uint8ss_append(const f_uint8ss_t source, f_uint8ss_t *destination);
-#endif // _di_f_type_uint8ss_append_
+#ifndef _di_f_uint8ss_append_
+ extern f_status_t f_uint8ss_append(const f_uint8ss_t source, f_uint8ss_t *destination);
+#endif // _di_f_uint8ss_append_
/**
* Resize the string uint8ss array.
* Errors (with error bit) from: f_memory_adjust().
* Errors (with error bit) from: f_memory_destroy().
*/
-#ifndef _di_f_type_uint8ss_adjust_
- extern f_status_t f_type_uint8ss_adjust(const f_array_length_t length, f_uint8ss_t *uint8ss);
-#endif // _di_f_type_uint8ss_adjust_
+#ifndef _di_f_uint8ss_adjust_
+ extern f_status_t f_uint8ss_adjust(const f_array_length_t length, f_uint8ss_t *uint8ss);
+#endif // _di_f_uint8ss_adjust_
/**
* Resize the string uint8ss array to a smaller size.
* Errors (with error bit) from: f_memory_adjust().
* Errors (with error bit) from: f_memory_destroy().
*/
-#ifndef _di_f_type_uint8ss_decimate_by_
- extern f_status_t f_type_uint8ss_decimate_by(const f_array_length_t amount, f_uint8ss_t *uint8ss);
-#endif // _di_f_type_uint8ss_decimate_by_
+#ifndef _di_f_uint8ss_decimate_by_
+ extern f_status_t f_uint8ss_decimate_by(const f_array_length_t amount, f_uint8ss_t *uint8ss);
+#endif // _di_f_uint8ss_decimate_by_
/**
* Resize the string uint8ss array to a smaller size.
* Errors (with error bit) from: f_memory_delete().
* Errors (with error bit) from: f_memory_resize().
*/
-#ifndef _di_f_type_uint8ss_decrease_by_
- extern f_status_t f_type_uint8ss_decrease_by(const f_array_length_t amount, f_uint8ss_t *uint8ss);
-#endif // _di_f_type_uint8ss_decrease_by_
+#ifndef _di_f_uint8ss_decrease_by_
+ extern f_status_t f_uint8ss_decrease_by(const f_array_length_t amount, f_uint8ss_t *uint8ss);
+#endif // _di_f_uint8ss_decrease_by_
/**
* Increase the size of the string uint8ss array, but only if necessary.
*
* Errors (with error bit) from: f_memory_resize().
*/
-#ifndef _di_f_type_uint8ss_increase_
- extern f_status_t f_type_uint8ss_increase(const uint16_t step, f_uint8ss_t *uint8ss);
-#endif // _di_f_type_uint8ss_increase_
+#ifndef _di_f_uint8ss_increase_
+ extern f_status_t f_uint8ss_increase(const uint16_t step, f_uint8ss_t *uint8ss);
+#endif // _di_f_uint8ss_increase_
/**
* Resize the string uint8ss array to a larger size.
*
* Errors (with error bit) from: f_memory_resize().
*/
-#ifndef _di_f_type_uint8ss_increase_by_
- extern f_status_t f_type_uint8ss_increase_by(const f_array_length_t amount, f_uint8ss_t *uint8ss);
-#endif // _di_f_type_uint8ss_increase_by_
+#ifndef _di_f_uint8ss_increase_by_
+ extern f_status_t f_uint8ss_increase_by(const f_array_length_t amount, f_uint8ss_t *uint8ss);
+#endif // _di_f_uint8ss_increase_by_
/**
* Resize the string uint8ss array.
* Errors (with error bit) from: f_memory_delete().
* Errors (with error bit) from: f_memory_resize().
*/
-#ifndef _di_f_type_uint8ss_resize_
- extern f_status_t f_type_uint8ss_resize(const f_array_length_t length, f_uint8ss_t *uint8ss);
-#endif // _di_f_type_uint8ss_resize_
+#ifndef _di_f_uint8ss_resize_
+ extern f_status_t f_uint8ss_resize(const f_array_length_t length, f_uint8ss_t *uint8ss);
+#endif // _di_f_uint8ss_resize_
#ifdef __cplusplus
} // extern "C"
extern "C" {
#endif
-#if !defined(_di_f_type_array_lengths_adjust_) || !defined(_di_f_type_array_lengths_decimate_by_)
- f_status_t private_f_type_array_lengths_adjust(const f_array_length_t length, f_array_lengths_t *array_lengths) {
+#if !defined(_di_f_array_lengths_adjust_) || !defined(_di_f_array_lengths_decimate_by_)
+ f_status_t private_f_array_lengths_adjust(const f_array_length_t length, f_array_lengths_t *array_lengths) {
const f_status_t status = f_memory_adjust(array_lengths->size, length, sizeof(f_array_length_t), (void **) & array_lengths->array);
return status;
}
-#endif // !defined(_di_f_type_array_lengths_adjust_) || !defined(_di_f_type_array_lengths_decimate_by_)
+#endif // !defined(_di_f_array_lengths_adjust_) || !defined(_di_f_array_lengths_decimate_by_)
-#if !defined(_di_f_type_array_lengths_append_) || !defined(_di_f_type_array_lengthss_append_)
- extern f_status_t private_f_type_array_lengths_append(const f_array_lengths_t source, f_array_lengths_t *destination) {
+#if !defined(_di_f_array_lengths_append_) || !defined(_di_f_array_lengthss_append_)
+ extern f_status_t private_f_array_lengths_append(const f_array_lengths_t source, f_array_lengths_t *destination) {
f_status_t status = F_none;
if (destination->used + source.used > destination->size) {
- status = private_f_type_array_lengths_adjust(destination->used + source.used, destination);
+ status = private_f_array_lengths_adjust(destination->used + source.used, destination);
if (F_status_is_error(status)) return status;
}
return F_none;
}
-#endif // !defined(_di_f_type_array_lengths_append_) || !defined(_di_f_type_array_lengthss_append_)
+#endif // !defined(_di_f_array_lengths_append_) || !defined(_di_f_array_lengthss_append_)
-#if !defined(_di_f_type_array_lengths_resize_) || !defined(_di_f_type_array_lengths_append_) || !defined(_di_f_type_array_lengths_decimate_by_) || !defined(_di_f_type_array_lengthss_append_)
- f_status_t private_f_type_array_lengths_resize(const f_array_length_t length, f_array_lengths_t *lengths) {
+#if !defined(_di_f_array_lengths_resize_) || !defined(_di_f_array_lengths_append_) || !defined(_di_f_array_lengths_decimate_by_) || !defined(_di_f_array_lengthss_append_)
+ f_status_t private_f_array_lengths_resize(const f_array_length_t length, f_array_lengths_t *lengths) {
const f_status_t status = f_memory_resize(lengths->size, length, sizeof(f_array_length_t), (void **) & lengths->array);
return status;
}
-#endif // !defined(_di_f_type_array_lengths_resize_) || !defined(_di_f_type_array_lengths_append_) || !defined(_di_f_type_array_lengths_decimate_by_) || !defined(_di_f_type_array_lengthss_append_)
+#endif // !defined(_di_f_array_lengths_resize_) || !defined(_di_f_array_lengths_append_) || !defined(_di_f_array_lengths_decimate_by_) || !defined(_di_f_array_lengthss_append_)
-#if !defined(_di_f_type_array_lengthss_adjust_) || !defined(_di_f_type_array_lengthss_decimate_by_)
- f_status_t private_f_type_array_lengthss_adjust(const f_array_length_t length, f_array_lengthss_t *lengthss) {
+#if !defined(_di_f_array_lengthss_adjust_) || !defined(_di_f_array_lengthss_decimate_by_)
+ f_status_t private_f_array_lengthss_adjust(const f_array_length_t length, f_array_lengthss_t *lengthss) {
f_status_t status = F_none;
return status;
}
-#endif // !defined(_di_f_type_array_lengthss_adjust_) || !defined(_di_f_type_array_lengthss_decimate_by_)
+#endif // !defined(_di_f_array_lengthss_adjust_) || !defined(_di_f_array_lengthss_decimate_by_)
-#if !defined(_di_f_type_array_lengthss_decrease_by_) || !defined(_di_f_type_array_lengthss_increase_) || !defined(_di_f_type_array_lengthss_increase_by_) || !defined(_di_f_type_array_lengthss_resize_)
- f_status_t private_f_type_array_lengthss_resize(const f_array_length_t length, f_array_lengthss_t *lengthss) {
+#if !defined(_di_f_array_lengthss_decrease_by_) || !defined(_di_f_array_lengthss_increase_) || !defined(_di_f_array_lengthss_increase_by_) || !defined(_di_f_array_lengthss_resize_)
+ f_status_t private_f_array_lengthss_resize(const f_array_length_t length, f_array_lengthss_t *lengthss) {
f_status_t status = F_none;
return status;
}
-#endif // !defined(_di_f_type_array_lengthss_decrease_by_) || !defined(_di_f_type_array_lengthss_increase_) || !defined(_di_f_type_array_lengthss_increase_by_) || !defined(_di_f_type_array_lengthss_resize_)
+#endif // !defined(_di_f_array_lengthss_decrease_by_) || !defined(_di_f_array_lengthss_increase_) || !defined(_di_f_array_lengthss_increase_by_) || !defined(_di_f_array_lengthss_resize_)
#ifdef __cplusplus
} // extern "C"
*
* Errors (with error bit) from: f_memory_adjust().
*
- * @see f_type_array_lengths_adjust()
- * @see f_type_array_lengths_decimate_by()
+ * @see f_array_lengths_adjust()
+ * @see f_array_lengths_decimate_by()
*/
-#if !defined(_di_f_type_array_lengths_adjust_) || !defined(_di_f_type_array_lengths_decimate_by_)
- extern f_status_t private_f_type_array_lengths_adjust(const f_array_length_t length, f_array_lengths_t *lengths) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_type_array_lengths_adjust_) || !defined(_di_f_type_array_lengths_decimate_by_)
+#if !defined(_di_f_array_lengths_adjust_) || !defined(_di_f_array_lengths_decimate_by_)
+ extern f_status_t private_f_array_lengths_adjust(const f_array_length_t length, f_array_lengths_t *lengths) F_attribute_visibility_internal_d;
+#endif // !defined(_di_f_array_lengths_adjust_) || !defined(_di_f_array_lengths_decimate_by_)
/**
* Private implementation for appending the array_length array.
*
* Errors (with error bit) from: f_memory_resize().
*
- * @see f_type_array_lengths_append()
- * @see f_type_array_lengthss_append()
+ * @see f_array_lengths_append()
+ * @see f_array_lengthss_append()
*/
-#if !defined(_di_f_type_array_lengths_append_) || !defined(_di_f_type_array_lengthss_append_)
- extern f_status_t private_f_type_array_lengths_append(const f_array_lengths_t source, f_array_lengths_t *destination) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_type_array_lengths_append_) || !defined(_di_f_type_array_lengthss_append_)
+#if !defined(_di_f_array_lengths_append_) || !defined(_di_f_array_lengthss_append_)
+ extern f_status_t private_f_array_lengths_append(const f_array_lengths_t source, f_array_lengths_t *destination) F_attribute_visibility_internal_d;
+#endif // !defined(_di_f_array_lengths_append_) || !defined(_di_f_array_lengthss_append_)
/**
* Private implementation for resizing the array_lengths array.
*
* Errors (with error bit) from: f_memory_resize().
*
- * @see f_type_array_lengths_resize()
- * @see f_type_array_lengths_append()
- * @see f_type_array_lengths_decimate_by()
- * @see f_type_array_lengthss_append()
+ * @see f_array_lengths_resize()
+ * @see f_array_lengths_append()
+ * @see f_array_lengths_decimate_by()
+ * @see f_array_lengthss_append()
*/
-#if !defined(_di_f_type_array_lengths_resize_) || !defined(_di_f_type_array_lengths_append_) || !defined(_di_f_type_array_lengths_decimate_by_) || !defined(_di_f_type_array_lengthss_append_)
- extern f_status_t private_f_type_array_lengths_resize(const f_array_length_t length, f_array_lengths_t *lengths) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_type_array_lengths_resize_) || !defined(_di_f_type_array_lengths_append_) || !defined(_di_f_type_array_lengths_decimate_by_) || !defined(_di_f_type_array_lengthss_append_)
+#if !defined(_di_f_array_lengths_resize_) || !defined(_di_f_array_lengths_append_) || !defined(_di_f_array_lengths_decimate_by_) || !defined(_di_f_array_lengthss_append_)
+ extern f_status_t private_f_array_lengths_resize(const f_array_length_t length, f_array_lengths_t *lengths) F_attribute_visibility_internal_d;
+#endif // !defined(_di_f_array_lengths_resize_) || !defined(_di_f_array_lengths_append_) || !defined(_di_f_array_lengths_decimate_by_) || !defined(_di_f_array_lengthss_append_)
/**
* Private implementation for resizing the lengthss array.
* Errors (with error bit) from: f_memory_adjust().
* Errors (with error bit) from: f_memory_destroy().
*
- * @see f_type_array_lengthss_adjust()
- * @see f_type_array_lengthss_decimate_by()
+ * @see f_array_lengthss_adjust()
+ * @see f_array_lengthss_decimate_by()
*/
-#if !defined(_di_f_type_array_lengthss_adjust_) || !defined(_di_f_type_array_lengthss_decimate_by_)
- extern f_status_t private_f_type_array_lengthss_adjust(const f_array_length_t length, f_array_lengthss_t *lengthss) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_type_array_lengthss_adjust_) || !defined(_di_f_type_array_lengthss_decimate_by_)
+#if !defined(_di_f_array_lengthss_adjust_) || !defined(_di_f_array_lengthss_decimate_by_)
+ extern f_status_t private_f_array_lengthss_adjust(const f_array_length_t length, f_array_lengthss_t *lengthss) F_attribute_visibility_internal_d;
+#endif // !defined(_di_f_array_lengthss_adjust_) || !defined(_di_f_array_lengthss_decimate_by_)
/**
* Private implementation for resizing the lengthss array.
* Errors (with error bit) from: f_memory_delete().
* Errors (with error bit) from: f_memory_resize().
*
- * @see f_type_array_lengthss_decrease_by()
- * @see f_type_array_lengthss_increase()
- * @see f_type_array_lengthss_increase_by()
- * @see f_type_array_lengthss_resize()
+ * @see f_array_lengthss_decrease_by()
+ * @see f_array_lengthss_increase()
+ * @see f_array_lengthss_increase_by()
+ * @see f_array_lengthss_resize()
*/
-#if !defined(_di_f_type_array_lengthss_decrease_by_) || !defined(_di_f_type_array_lengthss_increase_) || !defined(_di_f_type_array_lengthss_increase_by_) || !defined(_di_f_type_array_lengthss_resize_)
- extern f_status_t private_f_type_array_lengthss_resize(const f_array_length_t length, f_array_lengthss_t *lengthss) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_type_array_lengthss_decrease_by_) || !defined(_di_f_type_array_lengthss_increase_) || !defined(_di_f_type_array_lengthss_increase_by_) || !defined(_di_f_type_array_lengthss_resize_)
+#if !defined(_di_f_array_lengthss_decrease_by_) || !defined(_di_f_array_lengthss_increase_) || !defined(_di_f_array_lengthss_increase_by_) || !defined(_di_f_array_lengthss_resize_)
+ extern f_status_t private_f_array_lengthss_resize(const f_array_length_t length, f_array_lengthss_t *lengthss) F_attribute_visibility_internal_d;
+#endif // !defined(_di_f_array_lengthss_decrease_by_) || !defined(_di_f_array_lengthss_increase_) || !defined(_di_f_array_lengthss_increase_by_) || !defined(_di_f_array_lengthss_resize_)
#ifdef __cplusplus
} // extern "C"
extern "C" {
#endif
-#if !defined(_di_f_type_cells_adjust_) || !defined(_di_f_type_cells_decimate_by_)
- f_status_t private_f_type_cells_adjust(const f_array_length_t length, f_cells_t *cells) {
+#if !defined(_di_f_cells_adjust_) || !defined(_di_f_cells_decimate_by_)
+ f_status_t private_f_cells_adjust(const f_array_length_t length, f_cells_t *cells) {
const f_status_t status = f_memory_adjust(cells->size, length, sizeof(f_cell_t), (void **) & cells->array);
return status;
}
-#endif // !defined(_di_f_type_cells_adjust_) || !defined(_di_f_type_cells_decimate_by_)
+#endif // !defined(_di_f_cells_adjust_) || !defined(_di_f_cells_decimate_by_)
-#if !defined(_di_f_type_cells_append_) || !defined(_di_f_type_cellss_append_)
- extern f_status_t private_f_type_cells_append(const f_cells_t source, f_cells_t *destination) {
+#if !defined(_di_f_cells_append_) || !defined(_di_f_cellss_append_)
+ extern f_status_t private_f_cells_append(const f_cells_t source, f_cells_t *destination) {
f_status_t status = F_none;
if (destination->used + source.used > destination->size) {
- status = private_f_type_cells_adjust(destination->used + source.used, destination);
+ status = private_f_cells_adjust(destination->used + source.used, destination);
if (F_status_is_error(status)) return status;
}
return F_none;
}
-#endif // !defined(_di_f_type_cells_append_) || !defined(_di_f_type_cellss_append_)
+#endif // !defined(_di_f_cells_append_) || !defined(_di_f_cellss_append_)
-#if !defined(_di_f_type_cells_resize_) || !defined(_di_f_type_cells_append_) || !defined(_di_f_type_cells_decimate_by_) || !defined(_di_f_type_cellss_append_)
- f_status_t private_f_type_cells_resize(const f_array_length_t length, f_cells_t *cells) {
+#if !defined(_di_f_cells_resize_) || !defined(_di_f_cells_append_) || !defined(_di_f_cells_decimate_by_) || !defined(_di_f_cellss_append_)
+ f_status_t private_f_cells_resize(const f_array_length_t length, f_cells_t *cells) {
const f_status_t status = f_memory_resize(cells->size, length, sizeof(f_cell_t), (void **) & cells->array);
return status;
}
-#endif // !defined(_di_f_type_cells_resize_) || !defined(_di_f_type_cells_append_) || !defined(_di_f_type_cells_decimate_by_) || !defined(_di_f_type_cellss_append_)
+#endif // !defined(_di_f_cells_resize_) || !defined(_di_f_cells_append_) || !defined(_di_f_cells_decimate_by_) || !defined(_di_f_cellss_append_)
-#if !defined(_di_f_type_cellss_adjust_) || !defined(_di_f_type_cellss_decimate_by_)
- f_status_t private_f_type_cellss_adjust(const f_array_length_t length, f_cellss_t *cellss) {
+#if !defined(_di_f_cellss_adjust_) || !defined(_di_f_cellss_decimate_by_)
+ f_status_t private_f_cellss_adjust(const f_array_length_t length, f_cellss_t *cellss) {
f_status_t status = F_none;
return status;
}
-#endif // !defined(_di_f_type_cellss_adjust_) || !defined(_di_f_type_cellss_decimate_by_)
+#endif // !defined(_di_f_cellss_adjust_) || !defined(_di_f_cellss_decimate_by_)
-#if !defined(_di_f_type_cellss_decrease_by_) || !defined(_di_f_type_cellss_increase_) || !defined(_di_f_type_cellss_increase_by_) || !defined(_di_f_type_cellss_resize_)
- f_status_t private_f_type_cellss_resize(const f_array_length_t length, f_cellss_t *cellss) {
+#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_array_length_t length, f_cellss_t *cellss) {
f_status_t status = F_none;
return status;
}
-#endif // !defined(_di_f_type_cellss_decrease_by_) || !defined(_di_f_type_cellss_increase_) || !defined(_di_f_type_cellss_increase_by_) || !defined(_di_f_type_cellss_resize_)
+#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
} // extern "C"
*
* Errors (with error bit) from: f_memory_adjust().
*
- * @see f_type_cells_adjust()
- * @see f_type_cells_decimate_by()
+ * @see f_cells_adjust()
+ * @see f_cells_decimate_by()
*/
-#if !defined(_di_f_type_cells_adjust_) || !defined(_di_f_type_cells_decimate_by_)
- extern f_status_t private_f_type_cells_adjust(const f_array_length_t length, f_cells_t *cells) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_type_cells_adjust_) || !defined(_di_f_type_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_array_length_t length, f_cells_t *cells) F_attribute_visibility_internal_d;
+#endif // !defined(_di_f_cells_adjust_) || !defined(_di_f_cells_decimate_by_)
/**
* Private implementation for appending the cell array.
*
* Errors (with error bit) from: f_memory_resize().
*
- * @see f_type_cells_append()
- * @see f_type_cellss_append()
+ * @see f_cells_append()
+ * @see f_cellss_append()
*/
-#if !defined(_di_f_type_cells_append_) || !defined(_di_f_type_cellss_append_)
- extern f_status_t private_f_type_cells_append(const f_cells_t source, f_cells_t *destination) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_type_cells_append_) || !defined(_di_f_type_cellss_append_)
+#if !defined(_di_f_cells_append_) || !defined(_di_f_cellss_append_)
+ extern f_status_t private_f_cells_append(const f_cells_t source, f_cells_t *destination) F_attribute_visibility_internal_d;
+#endif // !defined(_di_f_cells_append_) || !defined(_di_f_cellss_append_)
/**
* Private implementation for resizing the cells array.
*
* Errors (with error bit) from: f_memory_resize().
*
- * @see f_type_cells_resize()
- * @see f_type_cells_append()
- * @see f_type_cells_decimate_by()
- * @see f_type_cellss_append()
+ * @see f_cells_resize()
+ * @see f_cells_append()
+ * @see f_cells_decimate_by()
+ * @see f_cellss_append()
*/
-#if !defined(_di_f_type_cells_resize_) || !defined(_di_f_type_cells_append_) || !defined(_di_f_type_cells_decimate_by_) || !defined(_di_f_type_cellss_append_)
- extern f_status_t private_f_type_cells_resize(const f_array_length_t length, f_cells_t *cells) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_type_cells_resize_) || !defined(_di_f_type_cells_append_) || !defined(_di_f_type_cells_decimate_by_) || !defined(_di_f_type_cellss_append_)
+#if !defined(_di_f_cells_resize_) || !defined(_di_f_cells_append_) || !defined(_di_f_cells_decimate_by_) || !defined(_di_f_cellss_append_)
+ extern f_status_t private_f_cells_resize(const f_array_length_t length, f_cells_t *cells) F_attribute_visibility_internal_d;
+#endif // !defined(_di_f_cells_resize_) || !defined(_di_f_cells_append_) || !defined(_di_f_cells_decimate_by_) || !defined(_di_f_cellss_append_)
/**
* Private implementation for resizing the cellss array.
* Errors (with error bit) from: f_memory_adjust().
* Errors (with error bit) from: f_memory_destroy().
*
- * @see f_type_cellss_adjust()
- * @see f_type_cellss_decimate_by()
+ * @see f_cellss_adjust()
+ * @see f_cellss_decimate_by()
*/
-#if !defined(_di_f_type_cellss_adjust_) || !defined(_di_f_type_cellss_decimate_by_)
- extern f_status_t private_f_type_cellss_adjust(const f_array_length_t length, f_cellss_t *cellss) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_type_cellss_adjust_) || !defined(_di_f_type_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_array_length_t length, f_cellss_t *cellss) F_attribute_visibility_internal_d;
+#endif // !defined(_di_f_cellss_adjust_) || !defined(_di_f_cellss_decimate_by_)
/**
* Private implementation for resizing the cellss array.
* Errors (with error bit) from: f_memory_delete().
* Errors (with error bit) from: f_memory_resize().
*
- * @see f_type_cellss_decrease_by()
- * @see f_type_cellss_increase()
- * @see f_type_cellss_increase_by()
- * @see f_type_cellss_resize()
+ * @see f_cellss_decrease_by()
+ * @see f_cellss_increase()
+ * @see f_cellss_increase_by()
+ * @see f_cellss_resize()
*/
-#if !defined(_di_f_type_cellss_decrease_by_) || !defined(_di_f_type_cellss_increase_) || !defined(_di_f_type_cellss_increase_by_) || !defined(_di_f_type_cellss_resize_)
- extern f_status_t private_f_type_cellss_resize(const f_array_length_t length, f_cellss_t *cellss) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_type_cellss_decrease_by_) || !defined(_di_f_type_cellss_increase_) || !defined(_di_f_type_cellss_increase_by_) || !defined(_di_f_type_cellss_resize_)
+#if !defined(_di_f_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_array_length_t length, f_cellss_t *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
} // extern "C"
extern "C" {
#endif
-#if !defined(_di_f_type_fll_ids_adjust_) || !defined(_di_f_type_fll_ids_decimate_by_)
- f_status_t private_f_type_fll_ids_adjust(const f_array_length_t length, f_fll_ids_t *ids) {
+#if !defined(_di_f_fll_ids_adjust_) || !defined(_di_f_fll_ids_decimate_by_)
+ f_status_t private_f_fll_ids_adjust(const f_array_length_t length, f_fll_ids_t *ids) {
const f_status_t status = f_memory_adjust(ids->size, length, sizeof(f_fll_id_t), (void **) & ids->array);
return status;
}
-#endif // !defined(_di_f_type_fll_ids_adjust_) || !defined(_di_f_type_fll_ids_decimate_by_)
+#endif // !defined(_di_f_fll_ids_adjust_) || !defined(_di_f_fll_ids_decimate_by_)
-#if !defined(_di_f_type_fll_ids_append_) || !defined(_di_f_type_fll_idss_append_)
- extern f_status_t private_f_type_fll_ids_append(const f_fll_ids_t source, f_fll_ids_t *destination) {
+#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_ids_t source, f_fll_ids_t *destination) {
f_status_t status = F_none;
if (destination->used + source.used > destination->size) {
- status = private_f_type_fll_ids_adjust(destination->used + source.used, destination);
+ status = private_f_fll_ids_adjust(destination->used + source.used, destination);
if (F_status_is_error(status)) return status;
}
return F_none;
}
-#endif // !defined(_di_f_type_fll_ids_append_) || !defined(_di_f_type_fll_idss_append_)
+#endif // !defined(_di_f_fll_ids_append_) || !defined(_di_f_fll_idss_append_)
-#if !defined(_di_f_type_fll_ids_resize_) || !defined(_di_f_type_fll_ids_append_) || !defined(_di_f_type_fll_ids_decimate_by_) || !defined(_di_f_type_fll_idss_append_)
- f_status_t private_f_type_fll_ids_resize(const f_array_length_t length, f_fll_ids_t *ids) {
+#if !defined(_di_f_fll_ids_resize_) || !defined(_di_f_fll_ids_append_) || !defined(_di_f_fll_ids_decimate_by_) || !defined(_di_f_fll_idss_append_)
+ f_status_t private_f_fll_ids_resize(const f_array_length_t length, f_fll_ids_t *ids) {
const f_status_t status = f_memory_resize(ids->size, length, sizeof(f_fll_id_t), (void **) & ids->array);
return status;
}
-#endif // !defined(_di_f_type_fll_ids_resize_) || !defined(_di_f_type_fll_ids_append_) || !defined(_di_f_type_fll_ids_decimate_by_) || !defined(_di_f_type_fll_idss_append_)
+#endif // !defined(_di_f_fll_ids_resize_) || !defined(_di_f_fll_ids_append_) || !defined(_di_f_fll_ids_decimate_by_) || !defined(_di_f_fll_idss_append_)
-#if !defined(_di_f_type_fll_idss_adjust_) || !defined(_di_f_type_fll_idss_decimate_by_)
- f_status_t private_f_type_fll_idss_adjust(const f_array_length_t length, f_fll_idss_t *idss) {
+#if !defined(_di_f_fll_idss_adjust_) || !defined(_di_f_fll_idss_decimate_by_)
+ f_status_t private_f_fll_idss_adjust(const f_array_length_t length, f_fll_idss_t *idss) {
f_status_t status = F_none;
return status;
}
-#endif // !defined(_di_f_type_fll_idss_adjust_) || !defined(_di_f_type_fll_idss_decimate_by_)
+#endif // !defined(_di_f_fll_idss_adjust_) || !defined(_di_f_fll_idss_decimate_by_)
-#if !defined(_di_f_type_fll_idss_decrease_by_) || !defined(_di_f_type_fll_idss_increase_) || !defined(_di_f_type_fll_idss_increase_by_) || !defined(_di_f_type_fll_idss_resize_)
- f_status_t private_f_type_fll_idss_resize(const f_array_length_t length, f_fll_idss_t *idss) {
+#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_array_length_t length, f_fll_idss_t *idss) {
f_status_t status = F_none;
return status;
}
-#endif // !defined(_di_f_type_fll_idss_decrease_by_) || !defined(_di_f_type_fll_idss_increase_) || !defined(_di_f_type_fll_idss_increase_by_) || !defined(_di_f_type_fll_idss_resize_)
+#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
} // extern "C"
*
* Errors (with error bit) from: f_memory_adjust().
*
- * @see f_type_statuss_adjust()
- * @see f_type_statuss_decimate_by()
+ * @see f_statuss_adjust()
+ * @see f_statuss_decimate_by()
*/
-#if !defined(_di_f_type_statuss_adjust_) || !defined(_di_f_type_statuss_decimate_by_)
- extern f_status_t private_f_type_statuss_adjust(const f_array_length_t length, f_statuss_t *statuss) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_type_statuss_adjust_) || !defined(_di_f_type_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_array_length_t length, f_statuss_t *statuss) F_attribute_visibility_internal_d;
+#endif // !defined(_di_f_statuss_adjust_) || !defined(_di_f_statuss_decimate_by_)
/**
* Private implementation for appending the status array.
*
* Errors (with error bit) from: f_memory_resize().
*
- * @see f_type_statuss_append()
- * @see f_type_statusss_append()
+ * @see f_statuss_append()
+ * @see f_statusss_append()
*/
-#if !defined(_di_f_type_statuss_append_) || !defined(_di_f_type_statusss_append_)
- extern f_status_t private_f_type_statuss_append(const f_statuss_t source, f_statuss_t *destination) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_type_statuss_append_) || !defined(_di_f_type_statusss_append_)
+#if !defined(_di_f_statuss_append_) || !defined(_di_f_statusss_append_)
+ extern f_status_t private_f_statuss_append(const f_statuss_t source, f_statuss_t *destination) F_attribute_visibility_internal_d;
+#endif // !defined(_di_f_statuss_append_) || !defined(_di_f_statusss_append_)
/**
* Private implementation for resizing the statuss array.
*
* Errors (with error bit) from: f_memory_resize().
*
- * @see f_type_statuss_resize()
- * @see f_type_statuss_append()
- * @see f_type_statuss_decimate_by()
- * @see f_type_statusss_append()
+ * @see f_statuss_resize()
+ * @see f_statuss_append()
+ * @see f_statuss_decimate_by()
+ * @see f_statusss_append()
*/
-#if !defined(_di_f_type_statuss_resize_) || !defined(_di_f_type_statuss_append_) || !defined(_di_f_type_statuss_decimate_by_) || !defined(_di_f_type_statusss_append_)
- extern f_status_t private_f_type_statuss_resize(const f_array_length_t length, f_statuss_t *statuss) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_type_statuss_resize_) || !defined(_di_f_type_statuss_append_) || !defined(_di_f_type_statuss_decimate_by_) || !defined(_di_f_type_statusss_append_)
+#if !defined(_di_f_statuss_resize_) || !defined(_di_f_statuss_append_) || !defined(_di_f_statuss_decimate_by_) || !defined(_di_f_statusss_append_)
+ extern f_status_t private_f_statuss_resize(const f_array_length_t length, f_statuss_t *statuss) F_attribute_visibility_internal_d;
+#endif // !defined(_di_f_statuss_resize_) || !defined(_di_f_statuss_append_) || !defined(_di_f_statuss_decimate_by_) || !defined(_di_f_statusss_append_)
/**
* Private implementation for resizing the statusss array.
* Errors (with error bit) from: f_memory_adjust().
* Errors (with error bit) from: f_memory_destroy().
*
- * @see f_type_statusss_adjust()
- * @see f_type_statusss_decimate_by()
+ * @see f_statusss_adjust()
+ * @see f_statusss_decimate_by()
*/
-#if !defined(_di_f_type_statusss_adjust_) || !defined(_di_f_type_statusss_decimate_by_)
- extern f_status_t private_f_type_statusss_adjust(const f_array_length_t length, f_statusss_t *statusss) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_type_statusss_adjust_) || !defined(_di_f_type_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_array_length_t length, f_statusss_t *statusss) F_attribute_visibility_internal_d;
+#endif // !defined(_di_f_statusss_adjust_) || !defined(_di_f_statusss_decimate_by_)
/**
* Private implementation for resizing the statusss array.
* Errors (with error bit) from: f_memory_delete().
* Errors (with error bit) from: f_memory_resize().
*
- * @see f_type_statusss_decrease_by()
- * @see f_type_statusss_increase()
- * @see f_type_statusss_increase_by()
- * @see f_type_statusss_resize()
+ * @see f_statusss_decrease_by()
+ * @see f_statusss_increase()
+ * @see f_statusss_increase_by()
+ * @see f_statusss_resize()
*/
-#if !defined(_di_f_type_statusss_decrease_by_) || !defined(_di_f_type_statusss_increase_) || !defined(_di_f_type_statusss_increase_by_) || !defined(_di_f_type_statusss_resize_)
- extern f_status_t private_f_type_statusss_resize(const f_array_length_t length, f_statusss_t *statusss) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_type_statusss_decrease_by_) || !defined(_di_f_type_statusss_increase_) || !defined(_di_f_type_statusss_increase_by_) || !defined(_di_f_type_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_array_length_t length, f_statusss_t *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_)
/**
* Private implementation for resizing the states array.
*
* Errors (with error bit) from: f_memory_adjust().
*
- * @see f_type_states_adjust()
- * @see f_type_states_decimate_by()
+ * @see f_states_adjust()
+ * @see f_states_decimate_by()
*/
-#if !defined(_di_f_type_states_adjust_) || !defined(_di_f_type_states_decimate_by_)
- extern f_status_t private_f_type_states_adjust(const f_array_length_t length, f_states_t *states) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_type_states_adjust_) || !defined(_di_f_type_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_array_length_t length, f_states_t *states) F_attribute_visibility_internal_d;
+#endif // !defined(_di_f_states_adjust_) || !defined(_di_f_states_decimate_by_)
/**
* Private implementation for appending the state array.
*
* Errors (with error bit) from: f_memory_resize().
*
- * @see f_type_states_append()
- * @see f_type_statess_append()
+ * @see f_states_append()
+ * @see f_statess_append()
*/
-#if !defined(_di_f_type_states_append_) || !defined(_di_f_type_statess_append_)
- extern f_status_t private_f_type_states_append(const f_states_t source, f_states_t *destination) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_type_states_append_) || !defined(_di_f_type_statess_append_)
+#if !defined(_di_f_states_append_) || !defined(_di_f_statess_append_)
+ extern f_status_t private_f_states_append(const f_states_t source, f_states_t *destination) F_attribute_visibility_internal_d;
+#endif // !defined(_di_f_states_append_) || !defined(_di_f_statess_append_)
/**
* Private implementation for resizing the states array.
*
* Errors (with error bit) from: f_memory_resize().
*
- * @see f_type_states_resize()
- * @see f_type_states_append()
- * @see f_type_states_decimate_by()
- * @see f_type_statess_append()
+ * @see f_states_resize()
+ * @see f_states_append()
+ * @see f_states_decimate_by()
+ * @see f_statess_append()
*/
-#if !defined(_di_f_type_states_resize_) || !defined(_di_f_type_states_append_) || !defined(_di_f_type_states_decimate_by_) || !defined(_di_f_type_statess_append_)
- extern f_status_t private_f_type_states_resize(const f_array_length_t length, f_states_t *states) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_type_states_resize_) || !defined(_di_f_type_states_append_) || !defined(_di_f_type_states_decimate_by_) || !defined(_di_f_type_statess_append_)
+#if !defined(_di_f_states_resize_) || !defined(_di_f_states_append_) || !defined(_di_f_states_decimate_by_) || !defined(_di_f_statess_append_)
+ extern f_status_t private_f_states_resize(const f_array_length_t length, f_states_t *states) F_attribute_visibility_internal_d;
+#endif // !defined(_di_f_states_resize_) || !defined(_di_f_states_append_) || !defined(_di_f_states_decimate_by_) || !defined(_di_f_statess_append_)
/**
* Private implementation for resizing the statess array.
* Errors (with error bit) from: f_memory_adjust().
* Errors (with error bit) from: f_memory_destroy().
*
- * @see f_type_statess_adjust()
- * @see f_type_statess_decimate_by()
+ * @see f_statess_adjust()
+ * @see f_statess_decimate_by()
*/
-#if !defined(_di_f_type_statess_adjust_) || !defined(_di_f_type_statess_decimate_by_)
- extern f_status_t private_f_type_statess_adjust(const f_array_length_t length, f_statess_t *statess) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_type_statess_adjust_) || !defined(_di_f_type_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_array_length_t length, f_statess_t *statess) F_attribute_visibility_internal_d;
+#endif // !defined(_di_f_statess_adjust_) || !defined(_di_f_statess_decimate_by_)
/**
* Private implementation for resizing the statess array.
* Errors (with error bit) from: f_memory_delete().
* Errors (with error bit) from: f_memory_resize().
*
- * @see f_type_statess_decrease_by()
- * @see f_type_statess_increase()
- * @see f_type_statess_increase_by()
- * @see f_type_statess_resize()
+ * @see f_statess_decrease_by()
+ * @see f_statess_increase()
+ * @see f_statess_increase_by()
+ * @see f_statess_resize()
*/
-#if !defined(_di_f_type_statess_decrease_by_) || !defined(_di_f_type_statess_increase_) || !defined(_di_f_type_statess_increase_by_) || !defined(_di_f_type_statess_resize_)
- extern f_status_t private_f_type_statess_resize(const f_array_length_t length, f_statess_t *statess) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_type_statess_decrease_by_) || !defined(_di_f_type_statess_increase_) || !defined(_di_f_type_statess_increase_by_) || !defined(_di_f_type_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_array_length_t length, f_statess_t *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_)
/**
* Private implementation for resizing the cells array.
*
* Errors (with error bit) from: f_memory_adjust().
*
- * @see f_type_cells_adjust()
- * @see f_type_cells_decimate_by()
+ * @see f_cells_adjust()
+ * @see f_cells_decimate_by()
*/
-#if !defined(_di_f_type_cells_adjust_) || !defined(_di_f_type_cells_decimate_by_)
- extern f_status_t private_f_type_cells_adjust(const f_array_length_t length, f_cells_t *cells) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_type_cells_adjust_) || !defined(_di_f_type_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_array_length_t length, f_cells_t *cells) F_attribute_visibility_internal_d;
+#endif // !defined(_di_f_cells_adjust_) || !defined(_di_f_cells_decimate_by_)
/**
* Private implementation for appending the cell array.
*
* Errors (with error bit) from: f_memory_resize().
*
- * @see f_type_cells_append()
- * @see f_type_cellss_append()
+ * @see f_cells_append()
+ * @see f_cellss_append()
*/
-#if !defined(_di_f_type_cells_append_) || !defined(_di_f_type_cellss_append_)
- extern f_status_t private_f_type_cells_append(const f_cells_t source, f_cells_t *destination) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_type_cells_append_) || !defined(_di_f_type_cellss_append_)
+#if !defined(_di_f_cells_append_) || !defined(_di_f_cellss_append_)
+ extern f_status_t private_f_cells_append(const f_cells_t source, f_cells_t *destination) F_attribute_visibility_internal_d;
+#endif // !defined(_di_f_cells_append_) || !defined(_di_f_cellss_append_)
/**
* Private implementation for resizing the cells array.
*
* Errors (with error bit) from: f_memory_resize().
*
- * @see f_type_cells_resize()
- * @see f_type_cells_append()
- * @see f_type_cells_decimate_by()
- * @see f_type_cellss_append()
+ * @see f_cells_resize()
+ * @see f_cells_append()
+ * @see f_cells_decimate_by()
+ * @see f_cellss_append()
*/
-#if !defined(_di_f_type_cells_resize_) || !defined(_di_f_type_cells_append_) || !defined(_di_f_type_cells_decimate_by_) || !defined(_di_f_type_cellss_append_)
- extern f_status_t private_f_type_cells_resize(const f_array_length_t length, f_cells_t *cells) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_type_cells_resize_) || !defined(_di_f_type_cells_append_) || !defined(_di_f_type_cells_decimate_by_) || !defined(_di_f_type_cellss_append_)
+#if !defined(_di_f_cells_resize_) || !defined(_di_f_cells_append_) || !defined(_di_f_cells_decimate_by_) || !defined(_di_f_cellss_append_)
+ extern f_status_t private_f_cells_resize(const f_array_length_t length, f_cells_t *cells) F_attribute_visibility_internal_d;
+#endif // !defined(_di_f_cells_resize_) || !defined(_di_f_cells_append_) || !defined(_di_f_cells_decimate_by_) || !defined(_di_f_cellss_append_)
/**
* Private implementation for resizing the cellss array.
* Errors (with error bit) from: f_memory_adjust().
* Errors (with error bit) from: f_memory_destroy().
*
- * @see f_type_cellss_adjust()
- * @see f_type_cellss_decimate_by()
+ * @see f_cellss_adjust()
+ * @see f_cellss_decimate_by()
*/
-#if !defined(_di_f_type_cellss_adjust_) || !defined(_di_f_type_cellss_decimate_by_)
- extern f_status_t private_f_type_cellss_adjust(const f_array_length_t length, f_cellss_t *cellss) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_type_cellss_adjust_) || !defined(_di_f_type_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_array_length_t length, f_cellss_t *cellss) F_attribute_visibility_internal_d;
+#endif // !defined(_di_f_cellss_adjust_) || !defined(_di_f_cellss_decimate_by_)
/**
* Private implementation for resizing the cellss array.
* Errors (with error bit) from: f_memory_delete().
* Errors (with error bit) from: f_memory_resize().
*
- * @see f_type_cellss_decrease_by()
- * @see f_type_cellss_increase()
- * @see f_type_cellss_increase_by()
- * @see f_type_cellss_resize()
+ * @see f_cellss_decrease_by()
+ * @see f_cellss_increase()
+ * @see f_cellss_increase_by()
+ * @see f_cellss_resize()
*/
-#if !defined(_di_f_type_cellss_decrease_by_) || !defined(_di_f_type_cellss_increase_) || !defined(_di_f_type_cellss_increase_by_) || !defined(_di_f_type_cellss_resize_)
- extern f_status_t private_f_type_cellss_resize(const f_array_length_t length, f_cellss_t *cellss) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_type_cellss_decrease_by_) || !defined(_di_f_type_cellss_increase_) || !defined(_di_f_type_cellss_increase_by_) || !defined(_di_f_type_cellss_resize_)
+#if !defined(_di_f_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_array_length_t length, f_cellss_t *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_)
/**
* Private implementation for resizing the ids array.
*
* Errors (with error bit) from: f_memory_adjust().
*
- * @see f_type_fll_ids_adjust()
- * @see f_type_fll_ids_decimate_by()
+ * @see f_fll_ids_adjust()
+ * @see f_fll_ids_decimate_by()
*/
-#if !defined(_di_f_type_fll_ids_adjust_) || !defined(_di_f_type_fll_ids_decimate_by_)
- extern f_status_t private_f_type_fll_ids_adjust(const f_array_length_t length, f_fll_ids_t *ids) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_type_fll_ids_adjust_) || !defined(_di_f_type_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_array_length_t length, f_fll_ids_t *ids) F_attribute_visibility_internal_d;
+#endif // !defined(_di_f_fll_ids_adjust_) || !defined(_di_f_fll_ids_decimate_by_)
/**
* Private implementation for appending the fll_id array.
*
* Errors (with error bit) from: f_memory_resize().
*
- * @see f_type_fll_ids_append()
- * @see f_type_fll_idss_append()
+ * @see f_fll_ids_append()
+ * @see f_fll_idss_append()
*/
-#if !defined(_di_f_type_fll_ids_append_) || !defined(_di_f_type_fll_idss_append_)
- extern f_status_t private_f_type_fll_ids_append(const f_fll_ids_t source, f_fll_ids_t *destination) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_type_fll_ids_append_) || !defined(_di_f_type_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_ids_t source, f_fll_ids_t *destination) F_attribute_visibility_internal_d;
+#endif // !defined(_di_f_fll_ids_append_) || !defined(_di_f_fll_idss_append_)
/**
* Private implementation for resizing the ids array.
*
* Errors (with error bit) from: f_memory_resize().
*
- * @see f_type_fll_ids_resize()
- * @see f_type_fll_ids_append()
- * @see f_type_fll_ids_decimate_by()
- * @see f_type_fll_idss_append()
+ * @see f_fll_ids_resize()
+ * @see f_fll_ids_append()
+ * @see f_fll_ids_decimate_by()
+ * @see f_fll_idss_append()
*/
-#if !defined(_di_f_type_fll_ids_resize_) || !defined(_di_f_type_fll_ids_append_) || !defined(_di_f_type_fll_ids_decimate_by_) || !defined(_di_f_type_fll_idss_append_)
- extern f_status_t private_f_type_fll_ids_resize(const f_array_length_t length, f_fll_ids_t *ids) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_type_fll_ids_resize_) || !defined(_di_f_type_fll_ids_append_) || !defined(_di_f_type_fll_ids_decimate_by_) || !defined(_di_f_type_fll_idss_append_)
+#if !defined(_di_f_fll_ids_resize_) || !defined(_di_f_fll_ids_append_) || !defined(_di_f_fll_ids_decimate_by_) || !defined(_di_f_fll_idss_append_)
+ extern f_status_t private_f_fll_ids_resize(const f_array_length_t length, f_fll_ids_t *ids) F_attribute_visibility_internal_d;
+#endif // !defined(_di_f_fll_ids_resize_) || !defined(_di_f_fll_ids_append_) || !defined(_di_f_fll_ids_decimate_by_) || !defined(_di_f_fll_idss_append_)
/**
* Private implementation for resizing the idss array.
* Errors (with error bit) from: f_memory_adjust().
* Errors (with error bit) from: f_memory_destroy().
*
- * @see f_type_fll_idss_adjust()
- * @see f_type_fll_idss_decimate_by()
+ * @see f_fll_idss_adjust()
+ * @see f_fll_idss_decimate_by()
*/
-#if !defined(_di_f_type_fll_idss_adjust_) || !defined(_di_f_type_fll_idss_decimate_by_)
- extern f_status_t private_f_type_fll_idss_adjust(const f_array_length_t length, f_fll_idss_t *idss) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_type_fll_idss_adjust_) || !defined(_di_f_type_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_array_length_t length, f_fll_idss_t *idss) F_attribute_visibility_internal_d;
+#endif // !defined(_di_f_fll_idss_adjust_) || !defined(_di_f_fll_idss_decimate_by_)
/**
* Private implementation for resizing the idss array.
* Errors (with error bit) from: f_memory_delete().
* Errors (with error bit) from: f_memory_resize().
*
- * @see f_type_fll_idss_decrease_by()
- * @see f_type_fll_idss_increase()
- * @see f_type_fll_idss_increase_by()
- * @see f_type_fll_idss_resize()
+ * @see f_fll_idss_decrease_by()
+ * @see f_fll_idss_increase()
+ * @see f_fll_idss_increase_by()
+ * @see f_fll_idss_resize()
*/
-#if !defined(_di_f_type_fll_idss_decrease_by_) || !defined(_di_f_type_fll_idss_increase_) || !defined(_di_f_type_fll_idss_increase_by_) || !defined(_di_f_type_fll_idss_resize_)
- extern f_status_t private_f_type_fll_idss_resize(const f_array_length_t length, f_fll_idss_t *idss) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_type_fll_idss_decrease_by_) || !defined(_di_f_type_fll_idss_increase_) || !defined(_di_f_type_fll_idss_increase_by_) || !defined(_di_f_type_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_array_length_t length, f_fll_idss_t *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_)
/**
* Private implementation for resizing the array_lengths array.
*
*
* Errors (with error bit) from: f_memory_adjust().
*
- * @see f_type_array_lengths_adjust()
- * @see f_type_array_lengths_decimate_by()
+ * @see f_array_lengths_adjust()
+ * @see f_array_lengths_decimate_by()
*/
-#if !defined(_di_f_type_array_lengths_adjust_) || !defined(_di_f_type_array_lengths_decimate_by_)
- extern f_status_t private_f_type_array_lengths_adjust(const f_array_length_t length, f_array_lengths_t *lengths) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_type_array_lengths_adjust_) || !defined(_di_f_type_array_lengths_decimate_by_)
+#if !defined(_di_f_array_lengths_adjust_) || !defined(_di_f_array_lengths_decimate_by_)
+ extern f_status_t private_f_array_lengths_adjust(const f_array_length_t length, f_array_lengths_t *lengths) F_attribute_visibility_internal_d;
+#endif // !defined(_di_f_array_lengths_adjust_) || !defined(_di_f_array_lengths_decimate_by_)
/**
* Private implementation for appending the array_length array.
*
* Errors (with error bit) from: f_memory_resize().
*
- * @see f_type_array_lengths_append()
- * @see f_type_array_lengthss_append()
+ * @see f_array_lengths_append()
+ * @see f_array_lengthss_append()
*/
-#if !defined(_di_f_type_array_lengths_append_) || !defined(_di_f_type_array_lengthss_append_)
- extern f_status_t private_f_type_array_lengths_append(const f_array_lengths_t source, f_array_lengths_t *destination) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_type_array_lengths_append_) || !defined(_di_f_type_array_lengthss_append_)
+#if !defined(_di_f_array_lengths_append_) || !defined(_di_f_array_lengthss_append_)
+ extern f_status_t private_f_array_lengths_append(const f_array_lengths_t source, f_array_lengths_t *destination) F_attribute_visibility_internal_d;
+#endif // !defined(_di_f_array_lengths_append_) || !defined(_di_f_array_lengthss_append_)
/**
* Private implementation for resizing the array_lengths array.
*
* Errors (with error bit) from: f_memory_resize().
*
- * @see f_type_array_lengths_resize()
- * @see f_type_array_lengths_append()
- * @see f_type_array_lengths_decimate_by()
- * @see f_type_array_lengthss_append()
+ * @see f_array_lengths_resize()
+ * @see f_array_lengths_append()
+ * @see f_array_lengths_decimate_by()
+ * @see f_array_lengthss_append()
*/
-#if !defined(_di_f_type_array_lengths_resize_) || !defined(_di_f_type_array_lengths_append_) || !defined(_di_f_type_array_lengths_decimate_by_) || !defined(_di_f_type_array_lengthss_append_)
- extern f_status_t private_f_type_array_lengths_resize(const f_array_length_t length, f_array_lengths_t *lengths) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_type_array_lengths_resize_) || !defined(_di_f_type_array_lengths_append_) || !defined(_di_f_type_array_lengths_decimate_by_) || !defined(_di_f_type_array_lengthss_append_)
+#if !defined(_di_f_array_lengths_resize_) || !defined(_di_f_array_lengths_append_) || !defined(_di_f_array_lengths_decimate_by_) || !defined(_di_f_array_lengthss_append_)
+ extern f_status_t private_f_array_lengths_resize(const f_array_length_t length, f_array_lengths_t *lengths) F_attribute_visibility_internal_d;
+#endif // !defined(_di_f_array_lengths_resize_) || !defined(_di_f_array_lengths_append_) || !defined(_di_f_array_lengths_decimate_by_) || !defined(_di_f_array_lengthss_append_)
/**
* Private implementation for resizing the lengthss array.
* Errors (with error bit) from: f_memory_adjust().
* Errors (with error bit) from: f_memory_destroy().
*
- * @see f_type_array_lengthss_adjust()
- * @see f_type_array_lengthss_decimate_by()
+ * @see f_array_lengthss_adjust()
+ * @see f_array_lengthss_decimate_by()
*/
-#if !defined(_di_f_type_array_lengthss_adjust_) || !defined(_di_f_type_array_lengthss_decimate_by_)
- extern f_status_t private_f_type_array_lengthss_adjust(const f_array_length_t length, f_array_lengthss_t *lengthss) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_type_array_lengthss_adjust_) || !defined(_di_f_type_array_lengthss_decimate_by_)
+#if !defined(_di_f_array_lengthss_adjust_) || !defined(_di_f_array_lengthss_decimate_by_)
+ extern f_status_t private_f_array_lengthss_adjust(const f_array_length_t length, f_array_lengthss_t *lengthss) F_attribute_visibility_internal_d;
+#endif // !defined(_di_f_array_lengthss_adjust_) || !defined(_di_f_array_lengthss_decimate_by_)
/**
* Private implementation for resizing the lengthss array.
* Errors (with error bit) from: f_memory_delete().
* Errors (with error bit) from: f_memory_resize().
*
- * @see f_type_array_lengthss_decrease_by()
- * @see f_type_array_lengthss_increase()
- * @see f_type_array_lengthss_increase_by()
- * @see f_type_array_lengthss_resize()
+ * @see f_array_lengthss_decrease_by()
+ * @see f_array_lengthss_increase()
+ * @see f_array_lengthss_increase_by()
+ * @see f_array_lengthss_resize()
*/
-#if !defined(_di_f_type_array_lengthss_decrease_by_) || !defined(_di_f_type_array_lengthss_increase_) || !defined(_di_f_type_array_lengthss_increase_by_) || !defined(_di_f_type_array_lengthss_resize_)
- extern f_status_t private_f_type_array_lengthss_resize(const f_array_length_t length, f_array_lengthss_t *lengthss) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_type_array_lengthss_decrease_by_) || !defined(_di_f_type_array_lengthss_increase_) || !defined(_di_f_type_array_lengthss_increase_by_) || !defined(_di_f_type_array_lengthss_resize_)
+#if !defined(_di_f_array_lengthss_decrease_by_) || !defined(_di_f_array_lengthss_increase_) || !defined(_di_f_array_lengthss_increase_by_) || !defined(_di_f_array_lengthss_resize_)
+ extern f_status_t private_f_array_lengthss_resize(const f_array_length_t length, f_array_lengthss_t *lengthss) F_attribute_visibility_internal_d;
+#endif // !defined(_di_f_array_lengthss_decrease_by_) || !defined(_di_f_array_lengthss_increase_) || !defined(_di_f_array_lengthss_increase_by_) || !defined(_di_f_array_lengthss_resize_)
/**
* Private implementation for resizing the int8s array.
*
* Errors (with error bit) from: f_memory_adjust().
*
- * @see f_type_int8s_adjust()
- * @see f_type_int8s_decimate_by()
+ * @see f_int8s_adjust()
+ * @see f_int8s_decimate_by()
*/
-#if !defined(_di_f_type_int8s_adjust_) || !defined(_di_f_type_int8s_decimate_by_)
- extern f_status_t private_f_type_int8s_adjust(const f_array_length_t length, f_int8s_t *int8s) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_type_int8s_adjust_) || !defined(_di_f_type_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_array_length_t length, f_int8s_t *int8s) F_attribute_visibility_internal_d;
+#endif // !defined(_di_f_int8s_adjust_) || !defined(_di_f_int8s_decimate_by_)
/**
* Private implementation for appending the int8 array.
*
* Errors (with error bit) from: f_memory_resize().
*
- * @see f_type_int8s_append()
- * @see f_type_int8ss_append()
+ * @see f_int8s_append()
+ * @see f_int8ss_append()
*/
-#if !defined(_di_f_type_int8s_append_) || !defined(_di_f_type_int8ss_append_)
- extern f_status_t private_f_type_int8s_append(const f_int8s_t source, f_int8s_t *destination) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_type_int8s_append_) || !defined(_di_f_type_int8ss_append_)
+#if !defined(_di_f_int8s_append_) || !defined(_di_f_int8ss_append_)
+ extern f_status_t private_f_int8s_append(const f_int8s_t source, f_int8s_t *destination) F_attribute_visibility_internal_d;
+#endif // !defined(_di_f_int8s_append_) || !defined(_di_f_int8ss_append_)
/**
* Private implementation for resizing the int8s array.
*
* Errors (with error bit) from: f_memory_resize().
*
- * @see f_type_int8s_resize()
- * @see f_type_int8s_append()
- * @see f_type_int8s_decimate_by()
- * @see f_type_int8ss_append()
+ * @see f_int8s_resize()
+ * @see f_int8s_append()
+ * @see f_int8s_decimate_by()
+ * @see f_int8ss_append()
*/
-#if !defined(_di_f_type_int8s_resize_) || !defined(_di_f_type_int8s_append_) || !defined(_di_f_type_int8s_decimate_by_) || !defined(_di_f_type_int8ss_append_)
- extern f_status_t private_f_type_int8s_resize(const f_array_length_t length, f_int8s_t *int8s) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_type_int8s_resize_) || !defined(_di_f_type_int8s_append_) || !defined(_di_f_type_int8s_decimate_by_) || !defined(_di_f_type_int8ss_append_)
+#if !defined(_di_f_int8s_resize_) || !defined(_di_f_int8s_append_) || !defined(_di_f_int8s_decimate_by_) || !defined(_di_f_int8ss_append_)
+ extern f_status_t private_f_int8s_resize(const f_array_length_t length, f_int8s_t *int8s) F_attribute_visibility_internal_d;
+#endif // !defined(_di_f_int8s_resize_) || !defined(_di_f_int8s_append_) || !defined(_di_f_int8s_decimate_by_) || !defined(_di_f_int8ss_append_)
/**
* Private implementation for resizing the int8ss array.
* Errors (with error bit) from: f_memory_adjust().
* Errors (with error bit) from: f_memory_destroy().
*
- * @see f_type_int8ss_adjust()
- * @see f_type_int8ss_decimate_by()
+ * @see f_int8ss_adjust()
+ * @see f_int8ss_decimate_by()
*/
-#if !defined(_di_f_type_int8ss_adjust_) || !defined(_di_f_type_int8ss_decimate_by_)
- extern f_status_t private_f_type_int8ss_adjust(const f_array_length_t length, f_int8ss_t *int8ss) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_type_int8ss_adjust_) || !defined(_di_f_type_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_array_length_t length, f_int8ss_t *int8ss) F_attribute_visibility_internal_d;
+#endif // !defined(_di_f_int8ss_adjust_) || !defined(_di_f_int8ss_decimate_by_)
/**
* Private implementation for resizing the int8ss array.
* Errors (with error bit) from: f_memory_delete().
* Errors (with error bit) from: f_memory_resize().
*
- * @see f_type_int8ss_decrease_by()
- * @see f_type_int8ss_increase()
- * @see f_type_int8ss_increase_by()
- * @see f_type_int8ss_resize()
+ * @see f_int8ss_decrease_by()
+ * @see f_int8ss_increase()
+ * @see f_int8ss_increase_by()
+ * @see f_int8ss_resize()
*/
-#if !defined(_di_f_type_int8ss_decrease_by_) || !defined(_di_f_type_int8ss_increase_) || !defined(_di_f_type_int8ss_increase_by_) || !defined(_di_f_type_int8ss_resize_)
- extern f_status_t private_f_type_int8ss_resize(const f_array_length_t length, f_int8ss_t *int8ss) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_type_int8ss_decrease_by_) || !defined(_di_f_type_int8ss_increase_) || !defined(_di_f_type_int8ss_increase_by_) || !defined(_di_f_type_int8ss_resize_)
+#if !defined(_di_f_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_array_length_t length, f_int8ss_t *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_)
/**
* Private implementation for resizing the uint8s array.
*
* Errors (with error bit) from: f_memory_adjust().
*
- * @see f_type_uint8s_adjust()
- * @see f_type_uint8s_decimate_by()
+ * @see f_uint8s_adjust()
+ * @see f_uint8s_decimate_by()
*/
-#if !defined(_di_f_type_uint8s_adjust_) || !defined(_di_f_type_uint8s_decimate_by_)
- extern f_status_t private_f_type_uint8s_adjust(const f_array_length_t length, f_uint8s_t *uint8s) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_type_uint8s_adjust_) || !defined(_di_f_type_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_array_length_t length, f_uint8s_t *uint8s) F_attribute_visibility_internal_d;
+#endif // !defined(_di_f_uint8s_adjust_) || !defined(_di_f_uint8s_decimate_by_)
/**
* Private implementation for appending the uint8 array.
*
* Errors (with error bit) from: f_memory_resize().
*
- * @see f_type_uint8s_append()
- * @see f_type_uint8ss_append()
+ * @see f_uint8s_append()
+ * @see f_uint8ss_append()
*/
-#if !defined(_di_f_type_uint8s_append_) || !defined(_di_f_type_uint8ss_append_)
- extern f_status_t private_f_type_uint8s_append(const f_uint8s_t source, f_uint8s_t *destination) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_type_uint8s_append_) || !defined(_di_f_type_uint8ss_append_)
+#if !defined(_di_f_uint8s_append_) || !defined(_di_f_uint8ss_append_)
+ extern f_status_t private_f_uint8s_append(const f_uint8s_t source, f_uint8s_t *destination) F_attribute_visibility_internal_d;
+#endif // !defined(_di_f_uint8s_append_) || !defined(_di_f_uint8ss_append_)
/**
* Private implementation for resizing the uint8s array.
*
* Errors (with error bit) from: f_memory_resize().
*
- * @see f_type_uint8s_resize()
- * @see f_type_uint8s_append()
- * @see f_type_uint8s_decimate_by()
- * @see f_type_uint8ss_append()
+ * @see f_uint8s_resize()
+ * @see f_uint8s_append()
+ * @see f_uint8s_decimate_by()
+ * @see f_uint8ss_append()
*/
-#if !defined(_di_f_type_uint8s_resize_) || !defined(_di_f_type_uint8s_append_) || !defined(_di_f_type_uint8s_decimate_by_) || !defined(_di_f_type_uint8ss_append_)
- extern f_status_t private_f_type_uint8s_resize(const f_array_length_t length, f_uint8s_t *uint8s) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_type_uint8s_resize_) || !defined(_di_f_type_uint8s_append_) || !defined(_di_f_type_uint8s_decimate_by_) || !defined(_di_f_type_uint8ss_append_)
+#if !defined(_di_f_uint8s_resize_) || !defined(_di_f_uint8s_append_) || !defined(_di_f_uint8s_decimate_by_) || !defined(_di_f_uint8ss_append_)
+ extern f_status_t private_f_uint8s_resize(const f_array_length_t length, f_uint8s_t *uint8s) F_attribute_visibility_internal_d;
+#endif // !defined(_di_f_uint8s_resize_) || !defined(_di_f_uint8s_append_) || !defined(_di_f_uint8s_decimate_by_) || !defined(_di_f_uint8ss_append_)
/**
* Private implementation for resizing the uint8ss array.
* Errors (with error bit) from: f_memory_adjust().
* Errors (with error bit) from: f_memory_destroy().
*
- * @see f_type_uint8ss_adjust()
- * @see f_type_uint8ss_decimate_by()
+ * @see f_uint8ss_adjust()
+ * @see f_uint8ss_decimate_by()
*/
-#if !defined(_di_f_type_uint8ss_adjust_) || !defined(_di_f_type_uint8ss_decimate_by_)
- extern f_status_t private_f_type_uint8ss_adjust(const f_array_length_t length, f_uint8ss_t *uint8ss) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_type_uint8ss_adjust_) || !defined(_di_f_type_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_array_length_t length, f_uint8ss_t *uint8ss) F_attribute_visibility_internal_d;
+#endif // !defined(_di_f_uint8ss_adjust_) || !defined(_di_f_uint8ss_decimate_by_)
/**
* Private implementation for resizing the uint8ss array.
* Errors (with error bit) from: f_memory_delete().
* Errors (with error bit) from: f_memory_resize().
*
- * @see f_type_uint8ss_decrease_by()
- * @see f_type_uint8ss_increase()
- * @see f_type_uint8ss_increase_by()
- * @see f_type_uint8ss_resize()
+ * @see f_uint8ss_decrease_by()
+ * @see f_uint8ss_increase()
+ * @see f_uint8ss_increase_by()
+ * @see f_uint8ss_resize()
*/
-#if !defined(_di_f_type_uint8ss_decrease_by_) || !defined(_di_f_type_uint8ss_increase_) || !defined(_di_f_type_uint8ss_increase_by_) || !defined(_di_f_type_uint8ss_resize_)
- extern f_status_t private_f_type_uint8ss_resize(const f_array_length_t length, f_uint8ss_t *uint8ss) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_type_uint8ss_decrease_by_) || !defined(_di_f_type_uint8ss_increase_) || !defined(_di_f_type_uint8ss_increase_by_) || !defined(_di_f_type_uint8ss_resize_)
+#if !defined(_di_f_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_array_length_t length, f_uint8ss_t *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_)
/**
* Private implementation for resizing the int16s array.
*
* Errors (with error bit) from: f_memory_adjust().
*
- * @see f_type_int16s_adjust()
- * @see f_type_int16s_decimate_by()
+ * @see f_int16s_adjust()
+ * @see f_int16s_decimate_by()
*/
-#if !defined(_di_f_type_int16s_adjust_) || !defined(_di_f_type_int16s_decimate_by_)
- extern f_status_t private_f_type_int16s_adjust(const f_array_length_t length, f_int16s_t *int16s) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_type_int16s_adjust_) || !defined(_di_f_type_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_array_length_t length, f_int16s_t *int16s) F_attribute_visibility_internal_d;
+#endif // !defined(_di_f_int16s_adjust_) || !defined(_di_f_int16s_decimate_by_)
/**
* Private implementation for appending the int16 array.
*
* Errors (with error bit) from: f_memory_resize().
*
- * @see f_type_int16s_append()
- * @see f_type_int16ss_append()
+ * @see f_int16s_append()
+ * @see f_int16ss_append()
*/
-#if !defined(_di_f_type_int16s_append_) || !defined(_di_f_type_int16ss_append_)
- extern f_status_t private_f_type_int16s_append(const f_int16s_t source, f_int16s_t *destination) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_type_int16s_append_) || !defined(_di_f_type_int16ss_append_)
+#if !defined(_di_f_int16s_append_) || !defined(_di_f_int16ss_append_)
+ extern f_status_t private_f_int16s_append(const f_int16s_t source, f_int16s_t *destination) F_attribute_visibility_internal_d;
+#endif // !defined(_di_f_int16s_append_) || !defined(_di_f_int16ss_append_)
/**
* Private implementation for resizing the int16s array.
*
* Errors (with error bit) from: f_memory_resize().
*
- * @see f_type_int16s_resize()
- * @see f_type_int16s_append()
- * @see f_type_int16s_decimate_by()
- * @see f_type_int16ss_append()
+ * @see f_int16s_resize()
+ * @see f_int16s_append()
+ * @see f_int16s_decimate_by()
+ * @see f_int16ss_append()
*/
-#if !defined(_di_f_type_int16s_resize_) || !defined(_di_f_type_int16s_append_) || !defined(_di_f_type_int16s_decimate_by_) || !defined(_di_f_type_int16ss_append_)
- extern f_status_t private_f_type_int16s_resize(const f_array_length_t length, f_int16s_t *int16s) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_type_int16s_resize_) || !defined(_di_f_type_int16s_append_) || !defined(_di_f_type_int16s_decimate_by_) || !defined(_di_f_type_int16ss_append_)
+#if !defined(_di_f_int16s_resize_) || !defined(_di_f_int16s_append_) || !defined(_di_f_int16s_decimate_by_) || !defined(_di_f_int16ss_append_)
+ extern f_status_t private_f_int16s_resize(const f_array_length_t length, f_int16s_t *int16s) F_attribute_visibility_internal_d;
+#endif // !defined(_di_f_int16s_resize_) || !defined(_di_f_int16s_append_) || !defined(_di_f_int16s_decimate_by_) || !defined(_di_f_int16ss_append_)
/**
* Private implementation for resizing the int16ss array.
* Errors (with error bit) from: f_memory_adjust().
* Errors (with error bit) from: f_memory_destroy().
*
- * @see f_type_int16ss_adjust()
- * @see f_type_int16ss_decimate_by()
+ * @see f_int16ss_adjust()
+ * @see f_int16ss_decimate_by()
*/
-#if !defined(_di_f_type_int16ss_adjust_) || !defined(_di_f_type_int16ss_decimate_by_)
- extern f_status_t private_f_type_int16ss_adjust(const f_array_length_t length, f_int16ss_t *int16ss) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_type_int16ss_adjust_) || !defined(_di_f_type_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_array_length_t length, f_int16ss_t *int16ss) F_attribute_visibility_internal_d;
+#endif // !defined(_di_f_int16ss_adjust_) || !defined(_di_f_int16ss_decimate_by_)
/**
* Private implementation for resizing the int16ss array.
* Errors (with error bit) from: f_memory_delete().
* Errors (with error bit) from: f_memory_resize().
*
- * @see f_type_int16ss_decrease_by()
- * @see f_type_int16ss_increase()
- * @see f_type_int16ss_increase_by()
- * @see f_type_int16ss_resize()
+ * @see f_int16ss_decrease_by()
+ * @see f_int16ss_increase()
+ * @see f_int16ss_increase_by()
+ * @see f_int16ss_resize()
*/
-#if !defined(_di_f_type_int16ss_decrease_by_) || !defined(_di_f_type_int16ss_increase_) || !defined(_di_f_type_int16ss_increase_by_) || !defined(_di_f_type_int16ss_resize_)
- extern f_status_t private_f_type_int16ss_resize(const f_array_length_t length, f_int16ss_t *int16ss) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_type_int16ss_decrease_by_) || !defined(_di_f_type_int16ss_increase_) || !defined(_di_f_type_int16ss_increase_by_) || !defined(_di_f_type_int16ss_resize_)
+#if !defined(_di_f_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_array_length_t length, f_int16ss_t *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_)
/**
* Private implementation for resizing the uint16s array.
*
* Errors (with error bit) from: f_memory_adjust().
*
- * @see f_type_uint16s_adjust()
- * @see f_type_uint16s_decimate_by()
+ * @see f_uint16s_adjust()
+ * @see f_uint16s_decimate_by()
*/
-#if !defined(_di_f_type_uint16s_adjust_) || !defined(_di_f_type_uint16s_decimate_by_)
- extern f_status_t private_f_type_uint16s_adjust(const f_array_length_t length, f_uint16s_t *uint16s) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_type_uint16s_adjust_) || !defined(_di_f_type_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_array_length_t length, f_uint16s_t *uint16s) F_attribute_visibility_internal_d;
+#endif // !defined(_di_f_uint16s_adjust_) || !defined(_di_f_uint16s_decimate_by_)
/**
* Private implementation for appending the uint16 array.
*
* Errors (with error bit) from: f_memory_resize().
*
- * @see f_type_uint16s_append()
- * @see f_type_uint16ss_append()
+ * @see f_uint16s_append()
+ * @see f_uint16ss_append()
*/
-#if !defined(_di_f_type_uint16s_append_) || !defined(_di_f_type_uint16ss_append_)
- extern f_status_t private_f_type_uint16s_append(const f_uint16s_t source, f_uint16s_t *destination) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_type_uint16s_append_) || !defined(_di_f_type_uint16ss_append_)
+#if !defined(_di_f_uint16s_append_) || !defined(_di_f_uint16ss_append_)
+ extern f_status_t private_f_uint16s_append(const f_uint16s_t source, f_uint16s_t *destination) F_attribute_visibility_internal_d;
+#endif // !defined(_di_f_uint16s_append_) || !defined(_di_f_uint16ss_append_)
/**
* Private implementation for resizing the uint16s array.
*
* Errors (with error bit) from: f_memory_resize().
*
- * @see f_type_uint16s_resize()
- * @see f_type_uint16s_append()
- * @see f_type_uint16s_decimate_by()
- * @see f_type_uint16ss_append()
+ * @see f_uint16s_resize()
+ * @see f_uint16s_append()
+ * @see f_uint16s_decimate_by()
+ * @see f_uint16ss_append()
*/
-#if !defined(_di_f_type_uint16s_resize_) || !defined(_di_f_type_uint16s_append_) || !defined(_di_f_type_uint16s_decimate_by_) || !defined(_di_f_type_uint16ss_append_)
- extern f_status_t private_f_type_uint16s_resize(const f_array_length_t length, f_uint16s_t *uint16s) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_type_uint16s_resize_) || !defined(_di_f_type_uint16s_append_) || !defined(_di_f_type_uint16s_decimate_by_) || !defined(_di_f_type_uint16ss_append_)
+#if !defined(_di_f_uint16s_resize_) || !defined(_di_f_uint16s_append_) || !defined(_di_f_uint16s_decimate_by_) || !defined(_di_f_uint16ss_append_)
+ extern f_status_t private_f_uint16s_resize(const f_array_length_t length, f_uint16s_t *uint16s) F_attribute_visibility_internal_d;
+#endif // !defined(_di_f_uint16s_resize_) || !defined(_di_f_uint16s_append_) || !defined(_di_f_uint16s_decimate_by_) || !defined(_di_f_uint16ss_append_)
/**
* Private implementation for resizing the uint16ss array.
* Errors (with error bit) from: f_memory_adjust().
* Errors (with error bit) from: f_memory_destroy().
*
- * @see f_type_uint16ss_adjust()
- * @see f_type_uint16ss_decimate_by()
+ * @see f_uint16ss_adjust()
+ * @see f_uint16ss_decimate_by()
*/
-#if !defined(_di_f_type_uint16ss_adjust_) || !defined(_di_f_type_uint16ss_decimate_by_)
- extern f_status_t private_f_type_uint16ss_adjust(const f_array_length_t length, f_uint16ss_t *uint16ss) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_type_uint16ss_adjust_) || !defined(_di_f_type_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_array_length_t length, f_uint16ss_t *uint16ss) F_attribute_visibility_internal_d;
+#endif // !defined(_di_f_uint16ss_adjust_) || !defined(_di_f_uint16ss_decimate_by_)
/**
* Private implementation for resizing the uint16ss array.
* Errors (with error bit) from: f_memory_delete().
* Errors (with error bit) from: f_memory_resize().
*
- * @see f_type_uint16ss_decrease_by()
- * @see f_type_uint16ss_increase()
- * @see f_type_uint16ss_increase_by()
- * @see f_type_uint16ss_resize()
+ * @see f_uint16ss_decrease_by()
+ * @see f_uint16ss_increase()
+ * @see f_uint16ss_increase_by()
+ * @see f_uint16ss_resize()
*/
-#if !defined(_di_f_type_uint16ss_decrease_by_) || !defined(_di_f_type_uint16ss_increase_) || !defined(_di_f_type_uint16ss_increase_by_) || !defined(_di_f_type_uint16ss_resize_)
- extern f_status_t private_f_type_uint16ss_resize(const f_array_length_t length, f_uint16ss_t *uint16ss) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_type_uint16ss_decrease_by_) || !defined(_di_f_type_uint16ss_increase_) || !defined(_di_f_type_uint16ss_increase_by_) || !defined(_di_f_type_uint16ss_resize_)
+#if !defined(_di_f_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_array_length_t length, f_uint16ss_t *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_)
/**
* Private implementation for resizing the int32s array.
*
* Errors (with error bit) from: f_memory_adjust().
*
- * @see f_type_int32s_adjust()
- * @see f_type_int32s_decimate_by()
+ * @see f_int32s_adjust()
+ * @see f_int32s_decimate_by()
*/
-#if !defined(_di_f_type_int32s_adjust_) || !defined(_di_f_type_int32s_decimate_by_)
- extern f_status_t private_f_type_int32s_adjust(const f_array_length_t length, f_int32s_t *int32s) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_type_int32s_adjust_) || !defined(_di_f_type_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_array_length_t length, f_int32s_t *int32s) F_attribute_visibility_internal_d;
+#endif // !defined(_di_f_int32s_adjust_) || !defined(_di_f_int32s_decimate_by_)
/**
* Private implementation for appending the int32 array.
*
* Errors (with error bit) from: f_memory_resize().
*
- * @see f_type_int32s_append()
- * @see f_type_int32ss_append()
+ * @see f_int32s_append()
+ * @see f_int32ss_append()
*/
-#if !defined(_di_f_type_int32s_append_) || !defined(_di_f_type_int32ss_append_)
- extern f_status_t private_f_type_int32s_append(const f_int32s_t source, f_int32s_t *destination) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_type_int32s_append_) || !defined(_di_f_type_int32ss_append_)
+#if !defined(_di_f_int32s_append_) || !defined(_di_f_int32ss_append_)
+ extern f_status_t private_f_int32s_append(const f_int32s_t source, f_int32s_t *destination) F_attribute_visibility_internal_d;
+#endif // !defined(_di_f_int32s_append_) || !defined(_di_f_int32ss_append_)
/**
* Private implementation for resizing the int32s array.
*
* Errors (with error bit) from: f_memory_resize().
*
- * @see f_type_int32s_resize()
- * @see f_type_int32s_append()
- * @see f_type_int32s_decimate_by()
- * @see f_type_int32ss_append()
+ * @see f_int32s_resize()
+ * @see f_int32s_append()
+ * @see f_int32s_decimate_by()
+ * @see f_int32ss_append()
*/
-#if !defined(_di_f_type_int32s_resize_) || !defined(_di_f_type_int32s_append_) || !defined(_di_f_type_int32s_decimate_by_) || !defined(_di_f_type_int32ss_append_)
- extern f_status_t private_f_type_int32s_resize(const f_array_length_t length, f_int32s_t *int32s) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_type_int32s_resize_) || !defined(_di_f_type_int32s_append_) || !defined(_di_f_type_int32s_decimate_by_) || !defined(_di_f_type_int32ss_append_)
+#if !defined(_di_f_int32s_resize_) || !defined(_di_f_int32s_append_) || !defined(_di_f_int32s_decimate_by_) || !defined(_di_f_int32ss_append_)
+ extern f_status_t private_f_int32s_resize(const f_array_length_t length, f_int32s_t *int32s) F_attribute_visibility_internal_d;
+#endif // !defined(_di_f_int32s_resize_) || !defined(_di_f_int32s_append_) || !defined(_di_f_int32s_decimate_by_) || !defined(_di_f_int32ss_append_)
/**
* Private implementation for resizing the int32ss array.
* Errors (with error bit) from: f_memory_adjust().
* Errors (with error bit) from: f_memory_destroy().
*
- * @see f_type_int32ss_adjust()
- * @see f_type_int32ss_decimate_by()
+ * @see f_int32ss_adjust()
+ * @see f_int32ss_decimate_by()
*/
-#if !defined(_di_f_type_int32ss_adjust_) || !defined(_di_f_type_int32ss_decimate_by_)
- extern f_status_t private_f_type_int32ss_adjust(const f_array_length_t length, f_int32ss_t *int32ss) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_type_int32ss_adjust_) || !defined(_di_f_type_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_array_length_t length, f_int32ss_t *int32ss) F_attribute_visibility_internal_d;
+#endif // !defined(_di_f_int32ss_adjust_) || !defined(_di_f_int32ss_decimate_by_)
/**
* Private implementation for resizing the int32ss array.
* Errors (with error bit) from: f_memory_delete().
* Errors (with error bit) from: f_memory_resize().
*
- * @see f_type_int32ss_decrease_by()
- * @see f_type_int32ss_increase()
- * @see f_type_int32ss_increase_by()
- * @see f_type_int32ss_resize()
+ * @see f_int32ss_decrease_by()
+ * @see f_int32ss_increase()
+ * @see f_int32ss_increase_by()
+ * @see f_int32ss_resize()
*/
-#if !defined(_di_f_type_int32ss_decrease_by_) || !defined(_di_f_type_int32ss_increase_) || !defined(_di_f_type_int32ss_increase_by_) || !defined(_di_f_type_int32ss_resize_)
- extern f_status_t private_f_type_int32ss_resize(const f_array_length_t length, f_int32ss_t *int32ss) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_type_int32ss_decrease_by_) || !defined(_di_f_type_int32ss_increase_) || !defined(_di_f_type_int32ss_increase_by_) || !defined(_di_f_type_int32ss_resize_)
+#if !defined(_di_f_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_array_length_t length, f_int32ss_t *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_)
/**
* Private implementation for resizing the uint32s array.
*
* Errors (with error bit) from: f_memory_adjust().
*
- * @see f_type_uint32s_adjust()
- * @see f_type_uint32s_decimate_by()
+ * @see f_uint32s_adjust()
+ * @see f_uint32s_decimate_by()
*/
-#if !defined(_di_f_type_uint32s_adjust_) || !defined(_di_f_type_uint32s_decimate_by_)
- extern f_status_t private_f_type_uint32s_adjust(const f_array_length_t length, f_uint32s_t *uint32s) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_type_uint32s_adjust_) || !defined(_di_f_type_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_array_length_t length, f_uint32s_t *uint32s) F_attribute_visibility_internal_d;
+#endif // !defined(_di_f_uint32s_adjust_) || !defined(_di_f_uint32s_decimate_by_)
/**
* Private implementation for appending the uint32 array.
*
* Errors (with error bit) from: f_memory_resize().
*
- * @see f_type_uint32s_append()
- * @see f_type_uint32ss_append()
+ * @see f_uint32s_append()
+ * @see f_uint32ss_append()
*/
-#if !defined(_di_f_type_uint32s_append_) || !defined(_di_f_type_uint32ss_append_)
- extern f_status_t private_f_type_uint32s_append(const f_uint32s_t source, f_uint32s_t *destination) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_type_uint32s_append_) || !defined(_di_f_type_uint32ss_append_)
+#if !defined(_di_f_uint32s_append_) || !defined(_di_f_uint32ss_append_)
+ extern f_status_t private_f_uint32s_append(const f_uint32s_t source, f_uint32s_t *destination) F_attribute_visibility_internal_d;
+#endif // !defined(_di_f_uint32s_append_) || !defined(_di_f_uint32ss_append_)
/**
* Private implementation for resizing the uint32s array.
*
* Errors (with error bit) from: f_memory_resize().
*
- * @see f_type_uint32s_resize()
- * @see f_type_uint32s_append()
- * @see f_type_uint32s_decimate_by()
- * @see f_type_uint32ss_append()
+ * @see f_uint32s_resize()
+ * @see f_uint32s_append()
+ * @see f_uint32s_decimate_by()
+ * @see f_uint32ss_append()
*/
-#if !defined(_di_f_type_uint32s_resize_) || !defined(_di_f_type_uint32s_append_) || !defined(_di_f_type_uint32s_decimate_by_) || !defined(_di_f_type_uint32ss_append_)
- extern f_status_t private_f_type_uint32s_resize(const f_array_length_t length, f_uint32s_t *uint32s) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_type_uint32s_resize_) || !defined(_di_f_type_uint32s_append_) || !defined(_di_f_type_uint32s_decimate_by_) || !defined(_di_f_type_uint32ss_append_)
+#if !defined(_di_f_uint32s_resize_) || !defined(_di_f_uint32s_append_) || !defined(_di_f_uint32s_decimate_by_) || !defined(_di_f_uint32ss_append_)
+ extern f_status_t private_f_uint32s_resize(const f_array_length_t length, f_uint32s_t *uint32s) F_attribute_visibility_internal_d;
+#endif // !defined(_di_f_uint32s_resize_) || !defined(_di_f_uint32s_append_) || !defined(_di_f_uint32s_decimate_by_) || !defined(_di_f_uint32ss_append_)
/**
* Private implementation for resizing the uint32ss array.
* Errors (with error bit) from: f_memory_adjust().
* Errors (with error bit) from: f_memory_destroy().
*
- * @see f_type_uint32ss_adjust()
- * @see f_type_uint32ss_decimate_by()
+ * @see f_uint32ss_adjust()
+ * @see f_uint32ss_decimate_by()
*/
-#if !defined(_di_f_type_uint32ss_adjust_) || !defined(_di_f_type_uint32ss_decimate_by_)
- extern f_status_t private_f_type_uint32ss_adjust(const f_array_length_t length, f_uint32ss_t *uint32ss) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_type_uint32ss_adjust_) || !defined(_di_f_type_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_array_length_t length, f_uint32ss_t *uint32ss) F_attribute_visibility_internal_d;
+#endif // !defined(_di_f_uint32ss_adjust_) || !defined(_di_f_uint32ss_decimate_by_)
/**
* Private implementation for resizing the uint32ss array.
* Errors (with error bit) from: f_memory_delete().
* Errors (with error bit) from: f_memory_resize().
*
- * @see f_type_uint32ss_decrease_by()
- * @see f_type_uint32ss_increase()
- * @see f_type_uint32ss_increase_by()
- * @see f_type_uint32ss_resize()
+ * @see f_uint32ss_decrease_by()
+ * @see f_uint32ss_increase()
+ * @see f_uint32ss_increase_by()
+ * @see f_uint32ss_resize()
*/
-#if !defined(_di_f_type_uint32ss_decrease_by_) || !defined(_di_f_type_uint32ss_increase_) || !defined(_di_f_type_uint32ss_increase_by_) || !defined(_di_f_type_uint32ss_resize_)
- extern f_status_t private_f_type_uint32ss_resize(const f_array_length_t length, f_uint32ss_t *uint32ss) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_type_uint32ss_decrease_by_) || !defined(_di_f_type_uint32ss_increase_) || !defined(_di_f_type_uint32ss_increase_by_) || !defined(_di_f_type_uint32ss_resize_)
+#if !defined(_di_f_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_array_length_t length, f_uint32ss_t *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_)
/**
* Private implementation for resizing the int64s array.
*
* Errors (with error bit) from: f_memory_adjust().
*
- * @see f_type_int64s_adjust()
- * @see f_type_int64s_decimate_by()
+ * @see f_int64s_adjust()
+ * @see f_int64s_decimate_by()
*/
-#if !defined(_di_f_type_int64s_adjust_) || !defined(_di_f_type_int64s_decimate_by_)
- extern f_status_t private_f_type_int64s_adjust(const f_array_length_t length, f_int64s_t *int64s) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_type_int64s_adjust_) || !defined(_di_f_type_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_array_length_t length, f_int64s_t *int64s) F_attribute_visibility_internal_d;
+#endif // !defined(_di_f_int64s_adjust_) || !defined(_di_f_int64s_decimate_by_)
/**
* Private implementation for appending the int64 array.
*
* Errors (with error bit) from: f_memory_resize().
*
- * @see f_type_int64s_append()
- * @see f_type_int64ss_append()
+ * @see f_int64s_append()
+ * @see f_int64ss_append()
*/
-#if !defined(_di_f_type_int64s_append_) || !defined(_di_f_type_int64ss_append_)
- extern f_status_t private_f_type_int64s_append(const f_int64s_t source, f_int64s_t *destination) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_type_int64s_append_) || !defined(_di_f_type_int64ss_append_)
+#if !defined(_di_f_int64s_append_) || !defined(_di_f_int64ss_append_)
+ extern f_status_t private_f_int64s_append(const f_int64s_t source, f_int64s_t *destination) F_attribute_visibility_internal_d;
+#endif // !defined(_di_f_int64s_append_) || !defined(_di_f_int64ss_append_)
/**
* Private implementation for resizing the int64s array.
*
* Errors (with error bit) from: f_memory_resize().
*
- * @see f_type_int64s_resize()
- * @see f_type_int64s_append()
- * @see f_type_int64s_decimate_by()
- * @see f_type_int64ss_append()
+ * @see f_int64s_resize()
+ * @see f_int64s_append()
+ * @see f_int64s_decimate_by()
+ * @see f_int64ss_append()
*/
-#if !defined(_di_f_type_int64s_resize_) || !defined(_di_f_type_int64s_append_) || !defined(_di_f_type_int64s_decimate_by_) || !defined(_di_f_type_int64ss_append_)
- extern f_status_t private_f_type_int64s_resize(const f_array_length_t length, f_int64s_t *int64s) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_type_int64s_resize_) || !defined(_di_f_type_int64s_append_) || !defined(_di_f_type_int64s_decimate_by_) || !defined(_di_f_type_int64ss_append_)
+#if !defined(_di_f_int64s_resize_) || !defined(_di_f_int64s_append_) || !defined(_di_f_int64s_decimate_by_) || !defined(_di_f_int64ss_append_)
+ extern f_status_t private_f_int64s_resize(const f_array_length_t length, f_int64s_t *int64s) F_attribute_visibility_internal_d;
+#endif // !defined(_di_f_int64s_resize_) || !defined(_di_f_int64s_append_) || !defined(_di_f_int64s_decimate_by_) || !defined(_di_f_int64ss_append_)
/**
* Private implementation for resizing the int64ss array.
* Errors (with error bit) from: f_memory_adjust().
* Errors (with error bit) from: f_memory_destroy().
*
- * @see f_type_int64ss_adjust()
- * @see f_type_int64ss_decimate_by()
+ * @see f_int64ss_adjust()
+ * @see f_int64ss_decimate_by()
*/
-#if !defined(_di_f_type_int64ss_adjust_) || !defined(_di_f_type_int64ss_decimate_by_)
- extern f_status_t private_f_type_int64ss_adjust(const f_array_length_t length, f_int64ss_t *int64ss) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_type_int64ss_adjust_) || !defined(_di_f_type_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_array_length_t length, f_int64ss_t *int64ss) F_attribute_visibility_internal_d;
+#endif // !defined(_di_f_int64ss_adjust_) || !defined(_di_f_int64ss_decimate_by_)
/**
* Private implementation for resizing the int64ss array.
* Errors (with error bit) from: f_memory_delete().
* Errors (with error bit) from: f_memory_resize().
*
- * @see f_type_int64ss_decrease_by()
- * @see f_type_int64ss_increase()
- * @see f_type_int64ss_increase_by()
- * @see f_type_int64ss_resize()
+ * @see f_int64ss_decrease_by()
+ * @see f_int64ss_increase()
+ * @see f_int64ss_increase_by()
+ * @see f_int64ss_resize()
*/
-#if !defined(_di_f_type_int64ss_decrease_by_) || !defined(_di_f_type_int64ss_increase_) || !defined(_di_f_type_int64ss_increase_by_) || !defined(_di_f_type_int64ss_resize_)
- extern f_status_t private_f_type_int64ss_resize(const f_array_length_t length, f_int64ss_t *int64ss) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_type_int64ss_decrease_by_) || !defined(_di_f_type_int64ss_increase_) || !defined(_di_f_type_int64ss_increase_by_) || !defined(_di_f_type_int64ss_resize_)
+#if !defined(_di_f_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_array_length_t length, f_int64ss_t *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_)
/**
* Private implementation for resizing the uint64s array.
*
* Errors (with error bit) from: f_memory_adjust().
*
- * @see f_type_uint64s_adjust()
- * @see f_type_uint64s_decimate_by()
+ * @see f_uint64s_adjust()
+ * @see f_uint64s_decimate_by()
*/
-#if !defined(_di_f_type_uint64s_adjust_) || !defined(_di_f_type_uint64s_decimate_by_)
- extern f_status_t private_f_type_uint64s_adjust(const f_array_length_t length, f_uint64s_t *uint64s) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_type_uint64s_adjust_) || !defined(_di_f_type_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_array_length_t length, f_uint64s_t *uint64s) F_attribute_visibility_internal_d;
+#endif // !defined(_di_f_uint64s_adjust_) || !defined(_di_f_uint64s_decimate_by_)
/**
* Private implementation for appending the uint64 array.
*
* Errors (with error bit) from: f_memory_resize().
*
- * @see f_type_uint64s_append()
- * @see f_type_uint64ss_append()
+ * @see f_uint64s_append()
+ * @see f_uint64ss_append()
*/
-#if !defined(_di_f_type_uint64s_append_) || !defined(_di_f_type_uint64ss_append_)
- extern f_status_t private_f_type_uint64s_append(const f_uint64s_t source, f_uint64s_t *destination) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_type_uint64s_append_) || !defined(_di_f_type_uint64ss_append_)
+#if !defined(_di_f_uint64s_append_) || !defined(_di_f_uint64ss_append_)
+ extern f_status_t private_f_uint64s_append(const f_uint64s_t source, f_uint64s_t *destination) F_attribute_visibility_internal_d;
+#endif // !defined(_di_f_uint64s_append_) || !defined(_di_f_uint64ss_append_)
/**
* Private implementation for resizing the uint64s array.
*
* Errors (with error bit) from: f_memory_resize().
*
- * @see f_type_uint64s_resize()
- * @see f_type_uint64s_append()
- * @see f_type_uint64s_decimate_by()
- * @see f_type_uint64ss_append()
+ * @see f_uint64s_resize()
+ * @see f_uint64s_append()
+ * @see f_uint64s_decimate_by()
+ * @see f_uint64ss_append()
*/
-#if !defined(_di_f_type_uint64s_resize_) || !defined(_di_f_type_uint64s_append_) || !defined(_di_f_type_uint64s_decimate_by_) || !defined(_di_f_type_uint64ss_append_)
- extern f_status_t private_f_type_uint64s_resize(const f_array_length_t length, f_uint64s_t *uint64s) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_type_uint64s_resize_) || !defined(_di_f_type_uint64s_append_) || !defined(_di_f_type_uint64s_decimate_by_) || !defined(_di_f_type_uint64ss_append_)
+#if !defined(_di_f_uint64s_resize_) || !defined(_di_f_uint64s_append_) || !defined(_di_f_uint64s_decimate_by_) || !defined(_di_f_uint64ss_append_)
+ extern f_status_t private_f_uint64s_resize(const f_array_length_t length, f_uint64s_t *uint64s) F_attribute_visibility_internal_d;
+#endif // !defined(_di_f_uint64s_resize_) || !defined(_di_f_uint64s_append_) || !defined(_di_f_uint64s_decimate_by_) || !defined(_di_f_uint64ss_append_)
/**
* Private implementation for resizing the uint64ss array.
* Errors (with error bit) from: f_memory_adjust().
* Errors (with error bit) from: f_memory_destroy().
*
- * @see f_type_uint64ss_adjust()
- * @see f_type_uint64ss_decimate_by()
+ * @see f_uint64ss_adjust()
+ * @see f_uint64ss_decimate_by()
*/
-#if !defined(_di_f_type_uint64ss_adjust_) || !defined(_di_f_type_uint64ss_decimate_by_)
- extern f_status_t private_f_type_uint64ss_adjust(const f_array_length_t length, f_uint64ss_t *uint64ss) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_type_uint64ss_adjust_) || !defined(_di_f_type_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_array_length_t length, f_uint64ss_t *uint64ss) F_attribute_visibility_internal_d;
+#endif // !defined(_di_f_uint64ss_adjust_) || !defined(_di_f_uint64ss_decimate_by_)
/**
* Private implementation for resizing the uint64ss array.
* Errors (with error bit) from: f_memory_delete().
* Errors (with error bit) from: f_memory_resize().
*
- * @see f_type_uint64ss_decrease_by()
- * @see f_type_uint64ss_increase()
- * @see f_type_uint64ss_increase_by()
- * @see f_type_uint64ss_resize()
+ * @see f_uint64ss_decrease_by()
+ * @see f_uint64ss_increase()
+ * @see f_uint64ss_increase_by()
+ * @see f_uint64ss_resize()
*/
-#if !defined(_di_f_type_uint64ss_decrease_by_) || !defined(_di_f_type_uint64ss_increase_) || !defined(_di_f_type_uint64ss_increase_by_) || !defined(_di_f_type_uint64ss_resize_)
- extern f_status_t private_f_type_uint64ss_resize(const f_array_length_t length, f_uint64ss_t *uint64ss) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_type_uint64ss_decrease_by_) || !defined(_di_f_type_uint64ss_increase_) || !defined(_di_f_type_uint64ss_increase_by_) || !defined(_di_f_type_uint64ss_resize_)
+#if !defined(_di_f_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_array_length_t length, f_uint64ss_t *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_)
/**
* Private implementation for resizing the int128s array.
*
* Errors (with error bit) from: f_memory_adjust().
*
- * @see f_type_int128s_adjust()
- * @see f_type_int128s_decimate_by()
+ * @see f_int128s_adjust()
+ * @see f_int128s_decimate_by()
*/
-#if !defined(_di_f_type_int128s_adjust_) || !defined(_di_f_type_int128s_decimate_by_)
- extern f_status_t private_f_type_int128s_adjust(const f_array_length_t length, f_int128s_t *int128s) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_type_int128s_adjust_) || !defined(_di_f_type_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_array_length_t length, f_int128s_t *int128s) F_attribute_visibility_internal_d;
+#endif // !defined(_di_f_int128s_adjust_) || !defined(_di_f_int128s_decimate_by_)
/**
* Private implementation for appending the int128 array.
*
* Errors (with error bit) from: f_memory_resize().
*
- * @see f_type_int128s_append()
- * @see f_type_int128ss_append()
+ * @see f_int128s_append()
+ * @see f_int128ss_append()
*/
-#if !defined(_di_f_type_int128s_append_) || !defined(_di_f_type_int128ss_append_)
- extern f_status_t private_f_type_int128s_append(const f_int128s_t source, f_int128s_t *destination) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_type_int128s_append_) || !defined(_di_f_type_int128ss_append_)
+#if !defined(_di_f_int128s_append_) || !defined(_di_f_int128ss_append_)
+ extern f_status_t private_f_int128s_append(const f_int128s_t source, f_int128s_t *destination) F_attribute_visibility_internal_d;
+#endif // !defined(_di_f_int128s_append_) || !defined(_di_f_int128ss_append_)
/**
* Private implementation for resizing the int128s array.
*
* Errors (with error bit) from: f_memory_resize().
*
- * @see f_type_int128s_resize()
- * @see f_type_int128s_append()
- * @see f_type_int128s_decimate_by()
- * @see f_type_int128ss_append()
+ * @see f_int128s_resize()
+ * @see f_int128s_append()
+ * @see f_int128s_decimate_by()
+ * @see f_int128ss_append()
*/
-#if !defined(_di_f_type_int128s_resize_) || !defined(_di_f_type_int128s_append_) || !defined(_di_f_type_int128s_decimate_by_) || !defined(_di_f_type_int128ss_append_)
- extern f_status_t private_f_type_int128s_resize(const f_array_length_t length, f_int128s_t *int128s) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_type_int128s_resize_) || !defined(_di_f_type_int128s_append_) || !defined(_di_f_type_int128s_decimate_by_) || !defined(_di_f_type_int128ss_append_)
+#if !defined(_di_f_int128s_resize_) || !defined(_di_f_int128s_append_) || !defined(_di_f_int128s_decimate_by_) || !defined(_di_f_int128ss_append_)
+ extern f_status_t private_f_int128s_resize(const f_array_length_t length, f_int128s_t *int128s) F_attribute_visibility_internal_d;
+#endif // !defined(_di_f_int128s_resize_) || !defined(_di_f_int128s_append_) || !defined(_di_f_int128s_decimate_by_) || !defined(_di_f_int128ss_append_)
/**
* Private implementation for resizing the int128ss array.
* Errors (with error bit) from: f_memory_adjust().
* Errors (with error bit) from: f_memory_destroy().
*
- * @see f_type_int128ss_adjust()
- * @see f_type_int128ss_decimate_by()
+ * @see f_int128ss_adjust()
+ * @see f_int128ss_decimate_by()
*/
-#if !defined(_di_f_type_int128ss_adjust_) || !defined(_di_f_type_int128ss_decimate_by_)
- extern f_status_t private_f_type_int128ss_adjust(const f_array_length_t length, f_int128ss_t *int128ss) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_type_int128ss_adjust_) || !defined(_di_f_type_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_array_length_t length, f_int128ss_t *int128ss) F_attribute_visibility_internal_d;
+#endif // !defined(_di_f_int128ss_adjust_) || !defined(_di_f_int128ss_decimate_by_)
/**
* Private implementation for resizing the int128ss array.
* Errors (with error bit) from: f_memory_delete().
* Errors (with error bit) from: f_memory_resize().
*
- * @see f_type_int128ss_decrease_by()
- * @see f_type_int128ss_increase()
- * @see f_type_int128ss_increase_by()
- * @see f_type_int128ss_resize()
+ * @see f_int128ss_decrease_by()
+ * @see f_int128ss_increase()
+ * @see f_int128ss_increase_by()
+ * @see f_int128ss_resize()
*/
-#if !defined(_di_f_type_int128ss_decrease_by_) || !defined(_di_f_type_int128ss_increase_) || !defined(_di_f_type_int128ss_increase_by_) || !defined(_di_f_type_int128ss_resize_)
- extern f_status_t private_f_type_int128ss_resize(const f_array_length_t length, f_int128ss_t *int128ss) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_type_int128ss_decrease_by_) || !defined(_di_f_type_int128ss_increase_) || !defined(_di_f_type_int128ss_increase_by_) || !defined(_di_f_type_int128ss_resize_)
+#if !defined(_di_f_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_array_length_t length, f_int128ss_t *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_)
/**
* Private implementation for resizing the uint128s array.
*
* Errors (with error bit) from: f_memory_adjust().
*
- * @see f_type_uint128s_adjust()
- * @see f_type_uint128s_decimate_by()
+ * @see f_uint128s_adjust()
+ * @see f_uint128s_decimate_by()
*/
-#if !defined(_di_f_type_uint128s_adjust_) || !defined(_di_f_type_uint128s_decimate_by_)
- extern f_status_t private_f_type_uint128s_adjust(const f_array_length_t length, f_uint128s_t *uint128s) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_type_uint128s_adjust_) || !defined(_di_f_type_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_array_length_t length, f_uint128s_t *uint128s) F_attribute_visibility_internal_d;
+#endif // !defined(_di_f_uint128s_adjust_) || !defined(_di_f_uint128s_decimate_by_)
/**
* Private implementation for appending the uint128 array.
*
* Errors (with error bit) from: f_memory_resize().
*
- * @see f_type_uint128s_append()
- * @see f_type_uint128ss_append()
+ * @see f_uint128s_append()
+ * @see f_uint128ss_append()
*/
-#if !defined(_di_f_type_uint128s_append_) || !defined(_di_f_type_uint128ss_append_)
- extern f_status_t private_f_type_uint128s_append(const f_uint128s_t source, f_uint128s_t *destination) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_type_uint128s_append_) || !defined(_di_f_type_uint128ss_append_)
+#if !defined(_di_f_uint128s_append_) || !defined(_di_f_uint128ss_append_)
+ extern f_status_t private_f_uint128s_append(const f_uint128s_t source, f_uint128s_t *destination) F_attribute_visibility_internal_d;
+#endif // !defined(_di_f_uint128s_append_) || !defined(_di_f_uint128ss_append_)
/**
* Private implementation for resizing the uint128s array.
*
* Errors (with error bit) from: f_memory_resize().
*
- * @see f_type_uint128s_resize()
- * @see f_type_uint128s_append()
- * @see f_type_uint128s_decimate_by()
- * @see f_type_uint128ss_append()
+ * @see f_uint128s_resize()
+ * @see f_uint128s_append()
+ * @see f_uint128s_decimate_by()
+ * @see f_uint128ss_append()
*/
-#if !defined(_di_f_type_uint128s_resize_) || !defined(_di_f_type_uint128s_append_) || !defined(_di_f_type_uint128s_decimate_by_) || !defined(_di_f_type_uint128ss_append_)
- extern f_status_t private_f_type_uint128s_resize(const f_array_length_t length, f_uint128s_t *uint128s) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_type_uint128s_resize_) || !defined(_di_f_type_uint128s_append_) || !defined(_di_f_type_uint128s_decimate_by_) || !defined(_di_f_type_uint128ss_append_)
+#if !defined(_di_f_uint128s_resize_) || !defined(_di_f_uint128s_append_) || !defined(_di_f_uint128s_decimate_by_) || !defined(_di_f_uint128ss_append_)
+ extern f_status_t private_f_uint128s_resize(const f_array_length_t length, f_uint128s_t *uint128s) F_attribute_visibility_internal_d;
+#endif // !defined(_di_f_uint128s_resize_) || !defined(_di_f_uint128s_append_) || !defined(_di_f_uint128s_decimate_by_) || !defined(_di_f_uint128ss_append_)
/**
* Private implementation for resizing the uint128ss array.
* Errors (with error bit) from: f_memory_adjust().
* Errors (with error bit) from: f_memory_destroy().
*
- * @see f_type_uint128ss_adjust()
- * @see f_type_uint128ss_decimate_by()
+ * @see f_uint128ss_adjust()
+ * @see f_uint128ss_decimate_by()
*/
-#if !defined(_di_f_type_uint128ss_adjust_) || !defined(_di_f_type_uint128ss_decimate_by_)
- extern f_status_t private_f_type_uint128ss_adjust(const f_array_length_t length, f_uint128ss_t *uint128ss) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_type_uint128ss_adjust_) || !defined(_di_f_type_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_array_length_t length, f_uint128ss_t *uint128ss) F_attribute_visibility_internal_d;
+#endif // !defined(_di_f_uint128ss_adjust_) || !defined(_di_f_uint128ss_decimate_by_)
/**
* Private implementation for resizing the uint128ss array.
* Errors (with error bit) from: f_memory_delete().
* Errors (with error bit) from: f_memory_resize().
*
- * @see f_type_uint128ss_decrease_by()
- * @see f_type_uint128ss_increase()
- * @see f_type_uint128ss_increase_by()
- * @see f_type_uint128ss_resize()
+ * @see f_uint128ss_decrease_by()
+ * @see f_uint128ss_increase()
+ * @see f_uint128ss_increase_by()
+ * @see f_uint128ss_resize()
*/
-#if !defined(_di_f_type_uint128ss_decrease_by_) || !defined(_di_f_type_uint128ss_increase_) || !defined(_di_f_type_uint128ss_increase_by_) || !defined(_di_f_type_uint128ss_resize_)
- extern f_status_t private_f_type_uint128ss_resize(const f_array_length_t length, f_uint128ss_t *uint128ss) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_type_uint128ss_decrease_by_) || !defined(_di_f_type_uint128ss_increase_) || !defined(_di_f_type_uint128ss_increase_by_) || !defined(_di_f_type_uint128ss_resize_)
+#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_array_length_t length, f_uint128ss_t *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
} // extern "C"
extern "C" {
#endif
-#if !defined(_di_f_type_int128s_adjust_) || !defined(_di_f_type_int128s_decimate_by_)
- f_status_t private_f_type_int128s_adjust(const f_array_length_t length, f_int128s_t *int128s) {
+#if !defined(_di_f_int128s_adjust_) || !defined(_di_f_int128s_decimate_by_)
+ f_status_t private_f_int128s_adjust(const f_array_length_t length, f_int128s_t *int128s) {
const f_status_t status = f_memory_adjust(int128s->size, length, sizeof(f_int128_t), (void **) & int128s->array);
return status;
}
-#endif // !defined(_di_f_type_int128s_adjust_) || !defined(_di_f_type_int128s_decimate_by_)
+#endif // !defined(_di_f_int128s_adjust_) || !defined(_di_f_int128s_decimate_by_)
-#if !defined(_di_f_type_int128s_append_) || !defined(_di_f_type_int128ss_append_)
- extern f_status_t private_f_type_int128s_append(const f_int128s_t source, f_int128s_t *destination) {
+#if !defined(_di_f_int128s_append_) || !defined(_di_f_int128ss_append_)
+ extern f_status_t private_f_int128s_append(const f_int128s_t source, f_int128s_t *destination) {
f_status_t status = F_none;
if (destination->used + source.used > destination->size) {
- status = private_f_type_int128s_adjust(destination->used + source.used, destination);
+ status = private_f_int128s_adjust(destination->used + source.used, destination);
if (F_status_is_error(status)) return status;
}
return F_none;
}
-#endif // !defined(_di_f_type_int128s_append_) || !defined(_di_f_type_int128ss_append_)
+#endif // !defined(_di_f_int128s_append_) || !defined(_di_f_int128ss_append_)
-#if !defined(_di_f_type_int128s_resize_) || !defined(_di_f_type_int128s_append_) || !defined(_di_f_type_int128s_decimate_by_) || !defined(_di_f_type_int128ss_append_)
- f_status_t private_f_type_int128s_resize(const f_array_length_t length, f_int128s_t *int128s) {
+#if !defined(_di_f_int128s_resize_) || !defined(_di_f_int128s_append_) || !defined(_di_f_int128s_decimate_by_) || !defined(_di_f_int128ss_append_)
+ f_status_t private_f_int128s_resize(const f_array_length_t length, f_int128s_t *int128s) {
const f_status_t status = f_memory_resize(int128s->size, length, sizeof(f_int128_t), (void **) & int128s->array);
return status;
}
-#endif // !defined(_di_f_type_int128s_resize_) || !defined(_di_f_type_int128s_append_) || !defined(_di_f_type_int128s_decimate_by_) || !defined(_di_f_type_int128ss_append_)
+#endif // !defined(_di_f_int128s_resize_) || !defined(_di_f_int128s_append_) || !defined(_di_f_int128s_decimate_by_) || !defined(_di_f_int128ss_append_)
-#if !defined(_di_f_type_int128ss_adjust_) || !defined(_di_f_type_int128ss_decimate_by_)
- f_status_t private_f_type_int128ss_adjust(const f_array_length_t length, f_int128ss_t *int128ss) {
+#if !defined(_di_f_int128ss_adjust_) || !defined(_di_f_int128ss_decimate_by_)
+ f_status_t private_f_int128ss_adjust(const f_array_length_t length, f_int128ss_t *int128ss) {
f_status_t status = F_none;
return status;
}
-#endif // !defined(_di_f_type_int128ss_adjust_) || !defined(_di_f_type_int128ss_decimate_by_)
+#endif // !defined(_di_f_int128ss_adjust_) || !defined(_di_f_int128ss_decimate_by_)
-#if !defined(_di_f_type_int128ss_decrease_by_) || !defined(_di_f_type_int128ss_increase_) || !defined(_di_f_type_int128ss_increase_by_) || !defined(_di_f_type_int128ss_resize_)
- f_status_t private_f_type_int128ss_resize(const f_array_length_t length, f_int128ss_t *int128ss) {
+#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_array_length_t length, f_int128ss_t *int128ss) {
f_status_t status = F_none;
return status;
}
-#endif // !defined(_di_f_type_int128ss_decrease_by_) || !defined(_di_f_type_int128ss_increase_) || !defined(_di_f_type_int128ss_increase_by_) || !defined(_di_f_type_int128ss_resize_)
+#endif // !defined(_di_f_int128ss_decrease_by_) || !defined(_di_f_int128ss_increase_) || !defined(_di_f_int128ss_increase_by_) || !defined(_di_f_int128ss_resize_)
-#if !defined(_di_f_type_uint128s_adjust_) || !defined(_di_f_type_uint128s_decimate_by_)
- f_status_t private_f_type_uint128s_adjust(const f_array_length_t length, f_uint128s_t *uint128s) {
+#if !defined(_di_f_uint128s_adjust_) || !defined(_di_f_uint128s_decimate_by_)
+ f_status_t private_f_uint128s_adjust(const f_array_length_t length, f_uint128s_t *uint128s) {
const f_status_t status = f_memory_adjust(uint128s->size, length, sizeof(f_uint128_t), (void **) & uint128s->array);
return status;
}
-#endif // !defined(_di_f_type_uint128s_adjust_) || !defined(_di_f_type_uint128s_decimate_by_)
+#endif // !defined(_di_f_uint128s_adjust_) || !defined(_di_f_uint128s_decimate_by_)
-#if !defined(_di_f_type_uint128s_append_) || !defined(_di_f_type_uint128ss_append_)
- extern f_status_t private_f_type_uint128s_append(const f_uint128s_t source, f_uint128s_t *destination) {
+#if !defined(_di_f_uint128s_append_) || !defined(_di_f_uint128ss_append_)
+ extern f_status_t private_f_uint128s_append(const f_uint128s_t source, f_uint128s_t *destination) {
f_status_t status = F_none;
if (destination->used + source.used > destination->size) {
- status = private_f_type_uint128s_adjust(destination->used + source.used, destination);
+ status = private_f_uint128s_adjust(destination->used + source.used, destination);
if (F_status_is_error(status)) return status;
}
return F_none;
}
-#endif // !defined(_di_f_type_uint128s_append_) || !defined(_di_f_type_uint128ss_append_)
+#endif // !defined(_di_f_uint128s_append_) || !defined(_di_f_uint128ss_append_)
-#if !defined(_di_f_type_uint128s_resize_) || !defined(_di_f_type_uint128s_append_) || !defined(_di_f_type_uint128s_decimate_by_) || !defined(_di_f_type_uint128ss_append_)
- f_status_t private_f_type_uint128s_resize(const f_array_length_t length, f_uint128s_t *uint128s) {
+#if !defined(_di_f_uint128s_resize_) || !defined(_di_f_uint128s_append_) || !defined(_di_f_uint128s_decimate_by_) || !defined(_di_f_uint128ss_append_)
+ f_status_t private_f_uint128s_resize(const f_array_length_t length, f_uint128s_t *uint128s) {
const f_status_t status = f_memory_resize(uint128s->size, length, sizeof(f_uint128_t), (void **) & uint128s->array);
return status;
}
-#endif // !defined(_di_f_type_uint128s_resize_) || !defined(_di_f_type_uint128s_append_) || !defined(_di_f_type_uint128s_decimate_by_) || !defined(_di_f_type_uint128ss_append_)
+#endif // !defined(_di_f_uint128s_resize_) || !defined(_di_f_uint128s_append_) || !defined(_di_f_uint128s_decimate_by_) || !defined(_di_f_uint128ss_append_)
-#if !defined(_di_f_type_uint128ss_adjust_) || !defined(_di_f_type_uint128ss_decimate_by_)
- f_status_t private_f_type_uint128ss_adjust(const f_array_length_t length, f_uint128ss_t *uint128ss) {
+#if !defined(_di_f_uint128ss_adjust_) || !defined(_di_f_uint128ss_decimate_by_)
+ f_status_t private_f_uint128ss_adjust(const f_array_length_t length, f_uint128ss_t *uint128ss) {
f_status_t status = F_none;
return status;
}
-#endif // !defined(_di_f_type_uint128ss_adjust_) || !defined(_di_f_type_uint128ss_decimate_by_)
+#endif // !defined(_di_f_uint128ss_adjust_) || !defined(_di_f_uint128ss_decimate_by_)
-#if !defined(_di_f_type_uint128ss_decrease_by_) || !defined(_di_f_type_uint128ss_increase_) || !defined(_di_f_type_uint128ss_increase_by_) || !defined(_di_f_type_uint128ss_resize_)
- f_status_t private_f_type_uint128ss_resize(const f_array_length_t length, f_uint128ss_t *uint128ss) {
+#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_array_length_t length, f_uint128ss_t *uint128ss) {
f_status_t status = F_none;
return status;
}
-#endif // !defined(_di_f_type_uint128ss_decrease_by_) || !defined(_di_f_type_uint128ss_increase_) || !defined(_di_f_type_uint128ss_increase_by_) || !defined(_di_f_type_uint128ss_resize_)
+#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
} // extern "C"
*
* Errors (with error bit) from: f_memory_adjust().
*
- * @see f_type_int128s_adjust()
- * @see f_type_int128s_decimate_by()
+ * @see f_int128s_adjust()
+ * @see f_int128s_decimate_by()
*/
-#if !defined(_di_f_type_int128s_adjust_) || !defined(_di_f_type_int128s_decimate_by_)
- extern f_status_t private_f_type_int128s_adjust(const f_array_length_t length, f_int128s_t *int128s) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_type_int128s_adjust_) || !defined(_di_f_type_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_array_length_t length, f_int128s_t *int128s) F_attribute_visibility_internal_d;
+#endif // !defined(_di_f_int128s_adjust_) || !defined(_di_f_int128s_decimate_by_)
/**
* Private implementation for appending the int128 array.
*
* Errors (with error bit) from: f_memory_resize().
*
- * @see f_type_int128s_append()
- * @see f_type_int128ss_append()
+ * @see f_int128s_append()
+ * @see f_int128ss_append()
*/
-#if !defined(_di_f_type_int128s_append_) || !defined(_di_f_type_int128ss_append_)
- extern f_status_t private_f_type_int128s_append(const f_int128s_t source, f_int128s_t *destination) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_type_int128s_append_) || !defined(_di_f_type_int128ss_append_)
+#if !defined(_di_f_int128s_append_) || !defined(_di_f_int128ss_append_)
+ extern f_status_t private_f_int128s_append(const f_int128s_t source, f_int128s_t *destination) F_attribute_visibility_internal_d;
+#endif // !defined(_di_f_int128s_append_) || !defined(_di_f_int128ss_append_)
/**
* Private implementation for resizing the int128s array.
*
* Errors (with error bit) from: f_memory_resize().
*
- * @see f_type_int128s_resize()
- * @see f_type_int128s_append()
- * @see f_type_int128s_decimate_by()
- * @see f_type_int128ss_append()
+ * @see f_int128s_resize()
+ * @see f_int128s_append()
+ * @see f_int128s_decimate_by()
+ * @see f_int128ss_append()
*/
-#if !defined(_di_f_type_int128s_resize_) || !defined(_di_f_type_int128s_append_) || !defined(_di_f_type_int128s_decimate_by_) || !defined(_di_f_type_int128ss_append_)
- extern f_status_t private_f_type_int128s_resize(const f_array_length_t length, f_int128s_t *int128s) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_type_int128s_resize_) || !defined(_di_f_type_int128s_append_) || !defined(_di_f_type_int128s_decimate_by_) || !defined(_di_f_type_int128ss_append_)
+#if !defined(_di_f_int128s_resize_) || !defined(_di_f_int128s_append_) || !defined(_di_f_int128s_decimate_by_) || !defined(_di_f_int128ss_append_)
+ extern f_status_t private_f_int128s_resize(const f_array_length_t length, f_int128s_t *int128s) F_attribute_visibility_internal_d;
+#endif // !defined(_di_f_int128s_resize_) || !defined(_di_f_int128s_append_) || !defined(_di_f_int128s_decimate_by_) || !defined(_di_f_int128ss_append_)
/**
* Private implementation for resizing the int128ss array.
* Errors (with error bit) from: f_memory_adjust().
* Errors (with error bit) from: f_memory_destroy().
*
- * @see f_type_int128ss_adjust()
- * @see f_type_int128ss_decimate_by()
+ * @see f_int128ss_adjust()
+ * @see f_int128ss_decimate_by()
*/
-#if !defined(_di_f_type_int128ss_adjust_) || !defined(_di_f_type_int128ss_decimate_by_)
- extern f_status_t private_f_type_int128ss_adjust(const f_array_length_t length, f_int128ss_t *int128ss) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_type_int128ss_adjust_) || !defined(_di_f_type_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_array_length_t length, f_int128ss_t *int128ss) F_attribute_visibility_internal_d;
+#endif // !defined(_di_f_int128ss_adjust_) || !defined(_di_f_int128ss_decimate_by_)
/**
* Private implementation for resizing the int128ss array.
* Errors (with error bit) from: f_memory_delete().
* Errors (with error bit) from: f_memory_resize().
*
- * @see f_type_int128ss_decrease_by()
- * @see f_type_int128ss_increase()
- * @see f_type_int128ss_increase_by()
- * @see f_type_int128ss_resize()
+ * @see f_int128ss_decrease_by()
+ * @see f_int128ss_increase()
+ * @see f_int128ss_increase_by()
+ * @see f_int128ss_resize()
*/
-#if !defined(_di_f_type_int128ss_decrease_by_) || !defined(_di_f_type_int128ss_increase_) || !defined(_di_f_type_int128ss_increase_by_) || !defined(_di_f_type_int128ss_resize_)
- extern f_status_t private_f_type_int128ss_resize(const f_array_length_t length, f_int128ss_t *int128ss) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_type_int128ss_decrease_by_) || !defined(_di_f_type_int128ss_increase_) || !defined(_di_f_type_int128ss_increase_by_) || !defined(_di_f_type_int128ss_resize_)
+#if !defined(_di_f_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_array_length_t length, f_int128ss_t *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_)
/**
* Private implementation for resizing the uint128s array.
*
* Errors (with error bit) from: f_memory_adjust().
*
- * @see f_type_uint128s_adjust()
- * @see f_type_uint128s_decimate_by()
+ * @see f_uint128s_adjust()
+ * @see f_uint128s_decimate_by()
*/
-#if !defined(_di_f_type_uint128s_adjust_) || !defined(_di_f_type_uint128s_decimate_by_)
- extern f_status_t private_f_type_uint128s_adjust(const f_array_length_t length, f_uint128s_t *uint128s) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_type_uint128s_adjust_) || !defined(_di_f_type_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_array_length_t length, f_uint128s_t *uint128s) F_attribute_visibility_internal_d;
+#endif // !defined(_di_f_uint128s_adjust_) || !defined(_di_f_uint128s_decimate_by_)
/**
* Private implementation for appending the uint128 array.
*
* Errors (with error bit) from: f_memory_resize().
*
- * @see f_type_uint128s_append()
- * @see f_type_uint128ss_append()
+ * @see f_uint128s_append()
+ * @see f_uint128ss_append()
*/
-#if !defined(_di_f_type_uint128s_append_) || !defined(_di_f_type_uint128ss_append_)
- extern f_status_t private_f_type_uint128s_append(const f_uint128s_t source, f_uint128s_t *destination) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_type_uint128s_append_) || !defined(_di_f_type_uint128ss_append_)
+#if !defined(_di_f_uint128s_append_) || !defined(_di_f_uint128ss_append_)
+ extern f_status_t private_f_uint128s_append(const f_uint128s_t source, f_uint128s_t *destination) F_attribute_visibility_internal_d;
+#endif // !defined(_di_f_uint128s_append_) || !defined(_di_f_uint128ss_append_)
/**
* Private implementation for resizing the uint128s array.
*
* Errors (with error bit) from: f_memory_resize().
*
- * @see f_type_uint128s_resize()
- * @see f_type_uint128s_append()
- * @see f_type_uint128s_decimate_by()
- * @see f_type_uint128ss_append()
+ * @see f_uint128s_resize()
+ * @see f_uint128s_append()
+ * @see f_uint128s_decimate_by()
+ * @see f_uint128ss_append()
*/
-#if !defined(_di_f_type_uint128s_resize_) || !defined(_di_f_type_uint128s_append_) || !defined(_di_f_type_uint128s_decimate_by_) || !defined(_di_f_type_uint128ss_append_)
- extern f_status_t private_f_type_uint128s_resize(const f_array_length_t length, f_uint128s_t *uint128s) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_type_uint128s_resize_) || !defined(_di_f_type_uint128s_append_) || !defined(_di_f_type_uint128s_decimate_by_) || !defined(_di_f_type_uint128ss_append_)
+#if !defined(_di_f_uint128s_resize_) || !defined(_di_f_uint128s_append_) || !defined(_di_f_uint128s_decimate_by_) || !defined(_di_f_uint128ss_append_)
+ extern f_status_t private_f_uint128s_resize(const f_array_length_t length, f_uint128s_t *uint128s) F_attribute_visibility_internal_d;
+#endif // !defined(_di_f_uint128s_resize_) || !defined(_di_f_uint128s_append_) || !defined(_di_f_uint128s_decimate_by_) || !defined(_di_f_uint128ss_append_)
/**
* Private implementation for resizing the uint128ss array.
* Errors (with error bit) from: f_memory_adjust().
* Errors (with error bit) from: f_memory_destroy().
*
- * @see f_type_uint128ss_adjust()
- * @see f_type_uint128ss_decimate_by()
+ * @see f_uint128ss_adjust()
+ * @see f_uint128ss_decimate_by()
*/
-#if !defined(_di_f_type_uint128ss_adjust_) || !defined(_di_f_type_uint128ss_decimate_by_)
- extern f_status_t private_f_type_uint128ss_adjust(const f_array_length_t length, f_uint128ss_t *uint128ss) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_type_uint128ss_adjust_) || !defined(_di_f_type_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_array_length_t length, f_uint128ss_t *uint128ss) F_attribute_visibility_internal_d;
+#endif // !defined(_di_f_uint128ss_adjust_) || !defined(_di_f_uint128ss_decimate_by_)
/**
* Private implementation for resizing the uint128ss array.
* Errors (with error bit) from: f_memory_delete().
* Errors (with error bit) from: f_memory_resize().
*
- * @see f_type_uint128ss_decrease_by()
- * @see f_type_uint128ss_increase()
- * @see f_type_uint128ss_increase_by()
- * @see f_type_uint128ss_resize()
+ * @see f_uint128ss_decrease_by()
+ * @see f_uint128ss_increase()
+ * @see f_uint128ss_increase_by()
+ * @see f_uint128ss_resize()
*/
-#if !defined(_di_f_type_uint128ss_decrease_by_) || !defined(_di_f_type_uint128ss_increase_) || !defined(_di_f_type_uint128ss_increase_by_) || !defined(_di_f_type_uint128ss_resize_)
- extern f_status_t private_f_type_uint128ss_resize(const f_array_length_t length, f_uint128ss_t *uint128ss) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_type_uint128ss_decrease_by_) || !defined(_di_f_type_uint128ss_increase_) || !defined(_di_f_type_uint128ss_increase_by_) || !defined(_di_f_type_uint128ss_resize_)
+#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_array_length_t length, f_uint128ss_t *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
} // extern "C"
extern "C" {
#endif
-#if !defined(_di_f_type_int16s_adjust_) || !defined(_di_f_type_int16s_decimate_by_)
- f_status_t private_f_type_int16s_adjust(const f_array_length_t length, f_int16s_t *int16s) {
+#if !defined(_di_f_int16s_adjust_) || !defined(_di_f_int16s_decimate_by_)
+ f_status_t private_f_int16s_adjust(const f_array_length_t length, f_int16s_t *int16s) {
const f_status_t status = f_memory_adjust(int16s->size, length, sizeof(int16_t), (void **) & int16s->array);
return status;
}
-#endif // !defined(_di_f_type_int16s_adjust_) || !defined(_di_f_type_int16s_decimate_by_)
+#endif // !defined(_di_f_int16s_adjust_) || !defined(_di_f_int16s_decimate_by_)
-#if !defined(_di_f_type_int16s_append_) || !defined(_di_f_type_int16ss_append_)
- extern f_status_t private_f_type_int16s_append(const f_int16s_t source, f_int16s_t *destination) {
+#if !defined(_di_f_int16s_append_) || !defined(_di_f_int16ss_append_)
+ extern f_status_t private_f_int16s_append(const f_int16s_t source, f_int16s_t *destination) {
f_status_t status = F_none;
if (destination->used + source.used > destination->size) {
- status = private_f_type_int16s_adjust(destination->used + source.used, destination);
+ status = private_f_int16s_adjust(destination->used + source.used, destination);
if (F_status_is_error(status)) return status;
}
return F_none;
}
-#endif // !defined(_di_f_type_int16s_append_) || !defined(_di_f_type_int16ss_append_)
+#endif // !defined(_di_f_int16s_append_) || !defined(_di_f_int16ss_append_)
-#if !defined(_di_f_type_int16s_resize_) || !defined(_di_f_type_int16s_append_) || !defined(_di_f_type_int16s_decimate_by_) || !defined(_di_f_type_int16ss_append_)
- f_status_t private_f_type_int16s_resize(const f_array_length_t length, f_int16s_t *int16s) {
+#if !defined(_di_f_int16s_resize_) || !defined(_di_f_int16s_append_) || !defined(_di_f_int16s_decimate_by_) || !defined(_di_f_int16ss_append_)
+ f_status_t private_f_int16s_resize(const f_array_length_t length, f_int16s_t *int16s) {
const f_status_t status = f_memory_resize(int16s->size, length, sizeof(int16_t), (void **) & int16s->array);
return status;
}
-#endif // !defined(_di_f_type_int16s_resize_) || !defined(_di_f_type_int16s_append_) || !defined(_di_f_type_int16s_decimate_by_) || !defined(_di_f_type_int16ss_append_)
+#endif // !defined(_di_f_int16s_resize_) || !defined(_di_f_int16s_append_) || !defined(_di_f_int16s_decimate_by_) || !defined(_di_f_int16ss_append_)
-#if !defined(_di_f_type_int16ss_adjust_) || !defined(_di_f_type_int16ss_decimate_by_)
- f_status_t private_f_type_int16ss_adjust(const f_array_length_t length, f_int16ss_t *int16ss) {
+#if !defined(_di_f_int16ss_adjust_) || !defined(_di_f_int16ss_decimate_by_)
+ f_status_t private_f_int16ss_adjust(const f_array_length_t length, f_int16ss_t *int16ss) {
f_status_t status = F_none;
return status;
}
-#endif // !defined(_di_f_type_int16ss_adjust_) || !defined(_di_f_type_int16ss_decimate_by_)
+#endif // !defined(_di_f_int16ss_adjust_) || !defined(_di_f_int16ss_decimate_by_)
-#if !defined(_di_f_type_int16ss_decrease_by_) || !defined(_di_f_type_int16ss_increase_) || !defined(_di_f_type_int16ss_increase_by_) || !defined(_di_f_type_int16ss_resize_)
- f_status_t private_f_type_int16ss_resize(const f_array_length_t length, f_int16ss_t *int16ss) {
+#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_array_length_t length, f_int16ss_t *int16ss) {
f_status_t status = F_none;
return status;
}
-#endif // !defined(_di_f_type_int16ss_decrease_by_) || !defined(_di_f_type_int16ss_increase_) || !defined(_di_f_type_int16ss_increase_by_) || !defined(_di_f_type_int16ss_resize_)
+#endif // !defined(_di_f_int16ss_decrease_by_) || !defined(_di_f_int16ss_increase_) || !defined(_di_f_int16ss_increase_by_) || !defined(_di_f_int16ss_resize_)
-#if !defined(_di_f_type_uint16s_adjust_) || !defined(_di_f_type_uint16s_decimate_by_)
- f_status_t private_f_type_uint16s_adjust(const f_array_length_t length, f_uint16s_t *uint16s) {
+#if !defined(_di_f_uint16s_adjust_) || !defined(_di_f_uint16s_decimate_by_)
+ f_status_t private_f_uint16s_adjust(const f_array_length_t length, f_uint16s_t *uint16s) {
const f_status_t status = f_memory_adjust(uint16s->size, length, sizeof(uint16_t), (void **) & uint16s->array);
return status;
}
-#endif // !defined(_di_f_type_uint16s_adjust_) || !defined(_di_f_type_uint16s_decimate_by_)
+#endif // !defined(_di_f_uint16s_adjust_) || !defined(_di_f_uint16s_decimate_by_)
-#if !defined(_di_f_type_uint16s_append_) || !defined(_di_f_type_uint16ss_append_)
- extern f_status_t private_f_type_uint16s_append(const f_uint16s_t source, f_uint16s_t *destination) {
+#if !defined(_di_f_uint16s_append_) || !defined(_di_f_uint16ss_append_)
+ extern f_status_t private_f_uint16s_append(const f_uint16s_t source, f_uint16s_t *destination) {
f_status_t status = F_none;
if (destination->used + source.used > destination->size) {
- status = private_f_type_uint16s_adjust(destination->used + source.used, destination);
+ status = private_f_uint16s_adjust(destination->used + source.used, destination);
if (F_status_is_error(status)) return status;
}
return F_none;
}
-#endif // !defined(_di_f_type_uint16s_append_) || !defined(_di_f_type_uint16ss_append_)
+#endif // !defined(_di_f_uint16s_append_) || !defined(_di_f_uint16ss_append_)
-#if !defined(_di_f_type_uint16s_resize_) || !defined(_di_f_type_uint16s_append_) || !defined(_di_f_type_uint16s_decimate_by_) || !defined(_di_f_type_uint16ss_append_)
- f_status_t private_f_type_uint16s_resize(const f_array_length_t length, f_uint16s_t *uint16s) {
+#if !defined(_di_f_uint16s_resize_) || !defined(_di_f_uint16s_append_) || !defined(_di_f_uint16s_decimate_by_) || !defined(_di_f_uint16ss_append_)
+ f_status_t private_f_uint16s_resize(const f_array_length_t length, f_uint16s_t *uint16s) {
const f_status_t status = f_memory_resize(uint16s->size, length, sizeof(uint16_t), (void **) & uint16s->array);
return status;
}
-#endif // !defined(_di_f_type_uint16s_resize_) || !defined(_di_f_type_uint16s_append_) || !defined(_di_f_type_uint16s_decimate_by_) || !defined(_di_f_type_uint16ss_append_)
+#endif // !defined(_di_f_uint16s_resize_) || !defined(_di_f_uint16s_append_) || !defined(_di_f_uint16s_decimate_by_) || !defined(_di_f_uint16ss_append_)
-#if !defined(_di_f_type_uint16ss_adjust_) || !defined(_di_f_type_uint16ss_decimate_by_)
- f_status_t private_f_type_uint16ss_adjust(const f_array_length_t length, f_uint16ss_t *uint16ss) {
+#if !defined(_di_f_uint16ss_adjust_) || !defined(_di_f_uint16ss_decimate_by_)
+ f_status_t private_f_uint16ss_adjust(const f_array_length_t length, f_uint16ss_t *uint16ss) {
f_status_t status = F_none;
return status;
}
-#endif // !defined(_di_f_type_uint16ss_adjust_) || !defined(_di_f_type_uint16ss_decimate_by_)
+#endif // !defined(_di_f_uint16ss_adjust_) || !defined(_di_f_uint16ss_decimate_by_)
-#if !defined(_di_f_type_uint16ss_decrease_by_) || !defined(_di_f_type_uint16ss_increase_) || !defined(_di_f_type_uint16ss_increase_by_) || !defined(_di_f_type_uint16ss_resize_)
- f_status_t private_f_type_uint16ss_resize(const f_array_length_t length, f_uint16ss_t *uint16ss) {
+#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_array_length_t length, f_uint16ss_t *uint16ss) {
f_status_t status = F_none;
return status;
}
-#endif // !defined(_di_f_type_uint16ss_decrease_by_) || !defined(_di_f_type_uint16ss_increase_) || !defined(_di_f_type_uint16ss_increase_by_) || !defined(_di_f_type_uint16ss_resize_)
+#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
} // extern "C"
*
* Errors (with error bit) from: f_memory_adjust().
*
- * @see f_type_int16s_adjust()
- * @see f_type_int16s_decimate_by()
+ * @see f_int16s_adjust()
+ * @see f_int16s_decimate_by()
*/
-#if !defined(_di_f_type_int16s_adjust_) || !defined(_di_f_type_int16s_decimate_by_)
- extern f_status_t private_f_type_int16s_adjust(const f_array_length_t length, f_int16s_t *int16s) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_type_int16s_adjust_) || !defined(_di_f_type_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_array_length_t length, f_int16s_t *int16s) F_attribute_visibility_internal_d;
+#endif // !defined(_di_f_int16s_adjust_) || !defined(_di_f_int16s_decimate_by_)
/**
* Private implementation for appending the int16 array.
*
* Errors (with error bit) from: f_memory_resize().
*
- * @see f_type_int16s_append()
- * @see f_type_int16ss_append()
+ * @see f_int16s_append()
+ * @see f_int16ss_append()
*/
-#if !defined(_di_f_type_int16s_append_) || !defined(_di_f_type_int16ss_append_)
- extern f_status_t private_f_type_int16s_append(const f_int16s_t source, f_int16s_t *destination) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_type_int16s_append_) || !defined(_di_f_type_int16ss_append_)
+#if !defined(_di_f_int16s_append_) || !defined(_di_f_int16ss_append_)
+ extern f_status_t private_f_int16s_append(const f_int16s_t source, f_int16s_t *destination) F_attribute_visibility_internal_d;
+#endif // !defined(_di_f_int16s_append_) || !defined(_di_f_int16ss_append_)
/**
* Private implementation for resizing the int16s array.
*
* Errors (with error bit) from: f_memory_resize().
*
- * @see f_type_int16s_resize()
- * @see f_type_int16s_append()
- * @see f_type_int16s_decimate_by()
- * @see f_type_int16ss_append()
+ * @see f_int16s_resize()
+ * @see f_int16s_append()
+ * @see f_int16s_decimate_by()
+ * @see f_int16ss_append()
*/
-#if !defined(_di_f_type_int16s_resize_) || !defined(_di_f_type_int16s_append_) || !defined(_di_f_type_int16s_decimate_by_) || !defined(_di_f_type_int16ss_append_)
- extern f_status_t private_f_type_int16s_resize(const f_array_length_t length, f_int16s_t *int16s) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_type_int16s_resize_) || !defined(_di_f_type_int16s_append_) || !defined(_di_f_type_int16s_decimate_by_) || !defined(_di_f_type_int16ss_append_)
+#if !defined(_di_f_int16s_resize_) || !defined(_di_f_int16s_append_) || !defined(_di_f_int16s_decimate_by_) || !defined(_di_f_int16ss_append_)
+ extern f_status_t private_f_int16s_resize(const f_array_length_t length, f_int16s_t *int16s) F_attribute_visibility_internal_d;
+#endif // !defined(_di_f_int16s_resize_) || !defined(_di_f_int16s_append_) || !defined(_di_f_int16s_decimate_by_) || !defined(_di_f_int16ss_append_)
/**
* Private implementation for resizing the int16ss array.
* Errors (with error bit) from: f_memory_adjust().
* Errors (with error bit) from: f_memory_destroy().
*
- * @see f_type_int16ss_adjust()
- * @see f_type_int16ss_decimate_by()
+ * @see f_int16ss_adjust()
+ * @see f_int16ss_decimate_by()
*/
-#if !defined(_di_f_type_int16ss_adjust_) || !defined(_di_f_type_int16ss_decimate_by_)
- extern f_status_t private_f_type_int16ss_adjust(const f_array_length_t length, f_int16ss_t *int16ss) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_type_int16ss_adjust_) || !defined(_di_f_type_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_array_length_t length, f_int16ss_t *int16ss) F_attribute_visibility_internal_d;
+#endif // !defined(_di_f_int16ss_adjust_) || !defined(_di_f_int16ss_decimate_by_)
/**
* Private implementation for resizing the int16ss array.
* Errors (with error bit) from: f_memory_delete().
* Errors (with error bit) from: f_memory_resize().
*
- * @see f_type_int16ss_decrease_by()
- * @see f_type_int16ss_increase()
- * @see f_type_int16ss_increase_by()
- * @see f_type_int16ss_resize()
+ * @see f_int16ss_decrease_by()
+ * @see f_int16ss_increase()
+ * @see f_int16ss_increase_by()
+ * @see f_int16ss_resize()
*/
-#if !defined(_di_f_type_int16ss_decrease_by_) || !defined(_di_f_type_int16ss_increase_) || !defined(_di_f_type_int16ss_increase_by_) || !defined(_di_f_type_int16ss_resize_)
- extern f_status_t private_f_type_int16ss_resize(const f_array_length_t length, f_int16ss_t *int16ss) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_type_int16ss_decrease_by_) || !defined(_di_f_type_int16ss_increase_) || !defined(_di_f_type_int16ss_increase_by_) || !defined(_di_f_type_int16ss_resize_)
+#if !defined(_di_f_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_array_length_t length, f_int16ss_t *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_)
/**
* Private implementation for resizing the uint16s array.
*
* Errors (with error bit) from: f_memory_adjust().
*
- * @see f_type_uint16s_adjust()
- * @see f_type_uint16s_decimate_by()
+ * @see f_uint16s_adjust()
+ * @see f_uint16s_decimate_by()
*/
-#if !defined(_di_f_type_uint16s_adjust_) || !defined(_di_f_type_uint16s_decimate_by_)
- extern f_status_t private_f_type_uint16s_adjust(const f_array_length_t length, f_uint16s_t *uint16s) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_type_uint16s_adjust_) || !defined(_di_f_type_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_array_length_t length, f_uint16s_t *uint16s) F_attribute_visibility_internal_d;
+#endif // !defined(_di_f_uint16s_adjust_) || !defined(_di_f_uint16s_decimate_by_)
/**
* Private implementation for appending the uint16 array.
*
* Errors (with error bit) from: f_memory_resize().
*
- * @see f_type_uint16s_append()
- * @see f_type_uint16ss_append()
+ * @see f_uint16s_append()
+ * @see f_uint16ss_append()
*/
-#if !defined(_di_f_type_uint16s_append_) || !defined(_di_f_type_uint16ss_append_)
- extern f_status_t private_f_type_uint16s_append(const f_uint16s_t source, f_uint16s_t *destination) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_type_uint16s_append_) || !defined(_di_f_type_uint16ss_append_)
+#if !defined(_di_f_uint16s_append_) || !defined(_di_f_uint16ss_append_)
+ extern f_status_t private_f_uint16s_append(const f_uint16s_t source, f_uint16s_t *destination) F_attribute_visibility_internal_d;
+#endif // !defined(_di_f_uint16s_append_) || !defined(_di_f_uint16ss_append_)
/**
* Private implementation for resizing the uint16s array.
*
* Errors (with error bit) from: f_memory_resize().
*
- * @see f_type_uint16s_resize()
- * @see f_type_uint16s_append()
- * @see f_type_uint16s_decimate_by()
- * @see f_type_uint16ss_append()
+ * @see f_uint16s_resize()
+ * @see f_uint16s_append()
+ * @see f_uint16s_decimate_by()
+ * @see f_uint16ss_append()
*/
-#if !defined(_di_f_type_uint16s_resize_) || !defined(_di_f_type_uint16s_append_) || !defined(_di_f_type_uint16s_decimate_by_) || !defined(_di_f_type_uint16ss_append_)
- extern f_status_t private_f_type_uint16s_resize(const f_array_length_t length, f_uint16s_t *uint16s) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_type_uint16s_resize_) || !defined(_di_f_type_uint16s_append_) || !defined(_di_f_type_uint16s_decimate_by_) || !defined(_di_f_type_uint16ss_append_)
+#if !defined(_di_f_uint16s_resize_) || !defined(_di_f_uint16s_append_) || !defined(_di_f_uint16s_decimate_by_) || !defined(_di_f_uint16ss_append_)
+ extern f_status_t private_f_uint16s_resize(const f_array_length_t length, f_uint16s_t *uint16s) F_attribute_visibility_internal_d;
+#endif // !defined(_di_f_uint16s_resize_) || !defined(_di_f_uint16s_append_) || !defined(_di_f_uint16s_decimate_by_) || !defined(_di_f_uint16ss_append_)
/**
* Private implementation for resizing the uint16ss array.
* Errors (with error bit) from: f_memory_adjust().
* Errors (with error bit) from: f_memory_destroy().
*
- * @see f_type_uint16ss_adjust()
- * @see f_type_uint16ss_decimate_by()
+ * @see f_uint16ss_adjust()
+ * @see f_uint16ss_decimate_by()
*/
-#if !defined(_di_f_type_uint16ss_adjust_) || !defined(_di_f_type_uint16ss_decimate_by_)
- extern f_status_t private_f_type_uint16ss_adjust(const f_array_length_t length, f_uint16ss_t *uint16ss) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_type_uint16ss_adjust_) || !defined(_di_f_type_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_array_length_t length, f_uint16ss_t *uint16ss) F_attribute_visibility_internal_d;
+#endif // !defined(_di_f_uint16ss_adjust_) || !defined(_di_f_uint16ss_decimate_by_)
/**
* Private implementation for resizing the uint16ss array.
* Errors (with error bit) from: f_memory_delete().
* Errors (with error bit) from: f_memory_resize().
*
- * @see f_type_uint16ss_decrease_by()
- * @see f_type_uint16ss_increase()
- * @see f_type_uint16ss_increase_by()
- * @see f_type_uint16ss_resize()
+ * @see f_uint16ss_decrease_by()
+ * @see f_uint16ss_increase()
+ * @see f_uint16ss_increase_by()
+ * @see f_uint16ss_resize()
*/
-#if !defined(_di_f_type_uint16ss_decrease_by_) || !defined(_di_f_type_uint16ss_increase_) || !defined(_di_f_type_uint16ss_increase_by_) || !defined(_di_f_type_uint16ss_resize_)
- extern f_status_t private_f_type_uint16ss_resize(const f_array_length_t length, f_uint16ss_t *uint16ss) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_type_uint16ss_decrease_by_) || !defined(_di_f_type_uint16ss_increase_) || !defined(_di_f_type_uint16ss_increase_by_) || !defined(_di_f_type_uint16ss_resize_)
+#if !defined(_di_f_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_array_length_t length, f_uint16ss_t *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
} // extern "C"
extern "C" {
#endif
-#if !defined(_di_f_type_int32s_adjust_) || !defined(_di_f_type_int32s_decimate_by_)
- f_status_t private_f_type_int32s_adjust(const f_array_length_t length, f_int32s_t *int32s) {
+#if !defined(_di_f_int32s_adjust_) || !defined(_di_f_int32s_decimate_by_)
+ f_status_t private_f_int32s_adjust(const f_array_length_t length, f_int32s_t *int32s) {
const f_status_t status = f_memory_adjust(int32s->size, length, sizeof(int32_t), (void **) & int32s->array);
return status;
}
-#endif // !defined(_di_f_type_int32s_adjust_) || !defined(_di_f_type_int32s_decimate_by_)
+#endif // !defined(_di_f_int32s_adjust_) || !defined(_di_f_int32s_decimate_by_)
-#if !defined(_di_f_type_int32s_append_) || !defined(_di_f_type_int32ss_append_)
- extern f_status_t private_f_type_int32s_append(const f_int32s_t source, f_int32s_t *destination) {
+#if !defined(_di_f_int32s_append_) || !defined(_di_f_int32ss_append_)
+ extern f_status_t private_f_int32s_append(const f_int32s_t source, f_int32s_t *destination) {
f_status_t status = F_none;
if (destination->used + source.used > destination->size) {
- status = private_f_type_int32s_adjust(destination->used + source.used, destination);
+ status = private_f_int32s_adjust(destination->used + source.used, destination);
if (F_status_is_error(status)) return status;
}
return F_none;
}
-#endif // !defined(_di_f_type_int32s_append_) || !defined(_di_f_type_int32ss_append_)
+#endif // !defined(_di_f_int32s_append_) || !defined(_di_f_int32ss_append_)
-#if !defined(_di_f_type_int32s_resize_) || !defined(_di_f_type_int32s_append_) || !defined(_di_f_type_int32s_decimate_by_) || !defined(_di_f_type_int32ss_append_)
- f_status_t private_f_type_int32s_resize(const f_array_length_t length, f_int32s_t *int32s) {
+#if !defined(_di_f_int32s_resize_) || !defined(_di_f_int32s_append_) || !defined(_di_f_int32s_decimate_by_) || !defined(_di_f_int32ss_append_)
+ f_status_t private_f_int32s_resize(const f_array_length_t length, f_int32s_t *int32s) {
const f_status_t status = f_memory_resize(int32s->size, length, sizeof(int32_t), (void **) & int32s->array);
return status;
}
-#endif // !defined(_di_f_type_int32s_resize_) || !defined(_di_f_type_int32s_append_) || !defined(_di_f_type_int32s_decimate_by_) || !defined(_di_f_type_int32ss_append_)
+#endif // !defined(_di_f_int32s_resize_) || !defined(_di_f_int32s_append_) || !defined(_di_f_int32s_decimate_by_) || !defined(_di_f_int32ss_append_)
-#if !defined(_di_f_type_int32ss_adjust_) || !defined(_di_f_type_int32ss_decimate_by_)
- f_status_t private_f_type_int32ss_adjust(const f_array_length_t length, f_int32ss_t *int32ss) {
+#if !defined(_di_f_int32ss_adjust_) || !defined(_di_f_int32ss_decimate_by_)
+ f_status_t private_f_int32ss_adjust(const f_array_length_t length, f_int32ss_t *int32ss) {
f_status_t status = F_none;
return status;
}
-#endif // !defined(_di_f_type_int32ss_adjust_) || !defined(_di_f_type_int32ss_decimate_by_)
+#endif // !defined(_di_f_int32ss_adjust_) || !defined(_di_f_int32ss_decimate_by_)
-#if !defined(_di_f_type_int32ss_decrease_by_) || !defined(_di_f_type_int32ss_increase_) || !defined(_di_f_type_int32ss_increase_by_) || !defined(_di_f_type_int32ss_resize_)
- f_status_t private_f_type_int32ss_resize(const f_array_length_t length, f_int32ss_t *int32ss) {
+#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_array_length_t length, f_int32ss_t *int32ss) {
f_status_t status = F_none;
return status;
}
-#endif // !defined(_di_f_type_int32ss_decrease_by_) || !defined(_di_f_type_int32ss_increase_) || !defined(_di_f_type_int32ss_increase_by_) || !defined(_di_f_type_int32ss_resize_)
+#endif // !defined(_di_f_int32ss_decrease_by_) || !defined(_di_f_int32ss_increase_) || !defined(_di_f_int32ss_increase_by_) || !defined(_di_f_int32ss_resize_)
-#if !defined(_di_f_type_uint32s_adjust_) || !defined(_di_f_type_uint32s_decimate_by_)
- f_status_t private_f_type_uint32s_adjust(const f_array_length_t length, f_uint32s_t *uint32s) {
+#if !defined(_di_f_uint32s_adjust_) || !defined(_di_f_uint32s_decimate_by_)
+ f_status_t private_f_uint32s_adjust(const f_array_length_t length, f_uint32s_t *uint32s) {
const f_status_t status = f_memory_adjust(uint32s->size, length, sizeof(uint32_t), (void **) & uint32s->array);
return status;
}
-#endif // !defined(_di_f_type_uint32s_adjust_) || !defined(_di_f_type_uint32s_decimate_by_)
+#endif // !defined(_di_f_uint32s_adjust_) || !defined(_di_f_uint32s_decimate_by_)
-#if !defined(_di_f_type_uint32s_append_) || !defined(_di_f_type_uint32ss_append_)
- extern f_status_t private_f_type_uint32s_append(const f_uint32s_t source, f_uint32s_t *destination) {
+#if !defined(_di_f_uint32s_append_) || !defined(_di_f_uint32ss_append_)
+ extern f_status_t private_f_uint32s_append(const f_uint32s_t source, f_uint32s_t *destination) {
f_status_t status = F_none;
if (destination->used + source.used > destination->size) {
- status = private_f_type_uint32s_adjust(destination->used + source.used, destination);
+ status = private_f_uint32s_adjust(destination->used + source.used, destination);
if (F_status_is_error(status)) return status;
}
return F_none;
}
-#endif // !defined(_di_f_type_uint32s_append_) || !defined(_di_f_type_uint32ss_append_)
+#endif // !defined(_di_f_uint32s_append_) || !defined(_di_f_uint32ss_append_)
-#if !defined(_di_f_type_uint32s_resize_) || !defined(_di_f_type_uint32s_append_) || !defined(_di_f_type_uint32s_decimate_by_) || !defined(_di_f_type_uint32ss_append_)
- f_status_t private_f_type_uint32s_resize(const f_array_length_t length, f_uint32s_t *uint32s) {
+#if !defined(_di_f_uint32s_resize_) || !defined(_di_f_uint32s_append_) || !defined(_di_f_uint32s_decimate_by_) || !defined(_di_f_uint32ss_append_)
+ f_status_t private_f_uint32s_resize(const f_array_length_t length, f_uint32s_t *uint32s) {
const f_status_t status = f_memory_resize(uint32s->size, length, sizeof(uint32_t), (void **) & uint32s->array);
return status;
}
-#endif // !defined(_di_f_type_uint32s_resize_) || !defined(_di_f_type_uint32s_append_) || !defined(_di_f_type_uint32s_decimate_by_) || !defined(_di_f_type_uint32ss_append_)
+#endif // !defined(_di_f_uint32s_resize_) || !defined(_di_f_uint32s_append_) || !defined(_di_f_uint32s_decimate_by_) || !defined(_di_f_uint32ss_append_)
-#if !defined(_di_f_type_uint32ss_adjust_) || !defined(_di_f_type_uint32ss_decimate_by_)
- f_status_t private_f_type_uint32ss_adjust(const f_array_length_t length, f_uint32ss_t *uint32ss) {
+#if !defined(_di_f_uint32ss_adjust_) || !defined(_di_f_uint32ss_decimate_by_)
+ f_status_t private_f_uint32ss_adjust(const f_array_length_t length, f_uint32ss_t *uint32ss) {
f_status_t status = F_none;
return status;
}
-#endif // !defined(_di_f_type_uint32ss_adjust_) || !defined(_di_f_type_uint32ss_decimate_by_)
+#endif // !defined(_di_f_uint32ss_adjust_) || !defined(_di_f_uint32ss_decimate_by_)
-#if !defined(_di_f_type_uint32ss_decrease_by_) || !defined(_di_f_type_uint32ss_increase_) || !defined(_di_f_type_uint32ss_increase_by_) || !defined(_di_f_type_uint32ss_resize_)
- f_status_t private_f_type_uint32ss_resize(const f_array_length_t length, f_uint32ss_t *uint32ss) {
+#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_array_length_t length, f_uint32ss_t *uint32ss) {
f_status_t status = F_none;
return status;
}
-#endif // !defined(_di_f_type_uint32ss_decrease_by_) || !defined(_di_f_type_uint32ss_increase_) || !defined(_di_f_type_uint32ss_increase_by_) || !defined(_di_f_type_uint32ss_resize_)
+#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
} // extern "C"
*
* Errors (with error bit) from: f_memory_adjust().
*
- * @see f_type_int32s_adjust()
- * @see f_type_int32s_decimate_by()
+ * @see f_int32s_adjust()
+ * @see f_int32s_decimate_by()
*/
-#if !defined(_di_f_type_int32s_adjust_) || !defined(_di_f_type_int32s_decimate_by_)
- extern f_status_t private_f_type_int32s_adjust(const f_array_length_t length, f_int32s_t *int32s) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_type_int32s_adjust_) || !defined(_di_f_type_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_array_length_t length, f_int32s_t *int32s) F_attribute_visibility_internal_d;
+#endif // !defined(_di_f_int32s_adjust_) || !defined(_di_f_int32s_decimate_by_)
/**
* Private implementation for appending the int32 array.
*
* Errors (with error bit) from: f_memory_resize().
*
- * @see f_type_int32s_append()
- * @see f_type_int32ss_append()
+ * @see f_int32s_append()
+ * @see f_int32ss_append()
*/
-#if !defined(_di_f_type_int32s_append_) || !defined(_di_f_type_int32ss_append_)
- extern f_status_t private_f_type_int32s_append(const f_int32s_t source, f_int32s_t *destination) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_type_int32s_append_) || !defined(_di_f_type_int32ss_append_)
+#if !defined(_di_f_int32s_append_) || !defined(_di_f_int32ss_append_)
+ extern f_status_t private_f_int32s_append(const f_int32s_t source, f_int32s_t *destination) F_attribute_visibility_internal_d;
+#endif // !defined(_di_f_int32s_append_) || !defined(_di_f_int32ss_append_)
/**
* Private implementation for resizing the int32s array.
*
* Errors (with error bit) from: f_memory_resize().
*
- * @see f_type_int32s_resize()
- * @see f_type_int32s_append()
- * @see f_type_int32s_decimate_by()
- * @see f_type_int32ss_append()
+ * @see f_int32s_resize()
+ * @see f_int32s_append()
+ * @see f_int32s_decimate_by()
+ * @see f_int32ss_append()
*/
-#if !defined(_di_f_type_int32s_resize_) || !defined(_di_f_type_int32s_append_) || !defined(_di_f_type_int32s_decimate_by_) || !defined(_di_f_type_int32ss_append_)
- extern f_status_t private_f_type_int32s_resize(const f_array_length_t length, f_int32s_t *int32s) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_type_int32s_resize_) || !defined(_di_f_type_int32s_append_) || !defined(_di_f_type_int32s_decimate_by_) || !defined(_di_f_type_int32ss_append_)
+#if !defined(_di_f_int32s_resize_) || !defined(_di_f_int32s_append_) || !defined(_di_f_int32s_decimate_by_) || !defined(_di_f_int32ss_append_)
+ extern f_status_t private_f_int32s_resize(const f_array_length_t length, f_int32s_t *int32s) F_attribute_visibility_internal_d;
+#endif // !defined(_di_f_int32s_resize_) || !defined(_di_f_int32s_append_) || !defined(_di_f_int32s_decimate_by_) || !defined(_di_f_int32ss_append_)
/**
* Private implementation for resizing the int32ss array.
* Errors (with error bit) from: f_memory_adjust().
* Errors (with error bit) from: f_memory_destroy().
*
- * @see f_type_int32ss_adjust()
- * @see f_type_int32ss_decimate_by()
+ * @see f_int32ss_adjust()
+ * @see f_int32ss_decimate_by()
*/
-#if !defined(_di_f_type_int32ss_adjust_) || !defined(_di_f_type_int32ss_decimate_by_)
- extern f_status_t private_f_type_int32ss_adjust(const f_array_length_t length, f_int32ss_t *int32ss) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_type_int32ss_adjust_) || !defined(_di_f_type_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_array_length_t length, f_int32ss_t *int32ss) F_attribute_visibility_internal_d;
+#endif // !defined(_di_f_int32ss_adjust_) || !defined(_di_f_int32ss_decimate_by_)
/**
* Private implementation for resizing the int32ss array.
* Errors (with error bit) from: f_memory_delete().
* Errors (with error bit) from: f_memory_resize().
*
- * @see f_type_int32ss_decrease_by()
- * @see f_type_int32ss_increase()
- * @see f_type_int32ss_increase_by()
- * @see f_type_int32ss_resize()
+ * @see f_int32ss_decrease_by()
+ * @see f_int32ss_increase()
+ * @see f_int32ss_increase_by()
+ * @see f_int32ss_resize()
*/
-#if !defined(_di_f_type_int32ss_decrease_by_) || !defined(_di_f_type_int32ss_increase_) || !defined(_di_f_type_int32ss_increase_by_) || !defined(_di_f_type_int32ss_resize_)
- extern f_status_t private_f_type_int32ss_resize(const f_array_length_t length, f_int32ss_t *int32ss) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_type_int32ss_decrease_by_) || !defined(_di_f_type_int32ss_increase_) || !defined(_di_f_type_int32ss_increase_by_) || !defined(_di_f_type_int32ss_resize_)
+#if !defined(_di_f_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_array_length_t length, f_int32ss_t *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_)
/**
* Private implementation for resizing the uint32s array.
*
* Errors (with error bit) from: f_memory_adjust().
*
- * @see f_type_uint32s_adjust()
- * @see f_type_uint32s_decimate_by()
+ * @see f_uint32s_adjust()
+ * @see f_uint32s_decimate_by()
*/
-#if !defined(_di_f_type_uint32s_adjust_) || !defined(_di_f_type_uint32s_decimate_by_)
- extern f_status_t private_f_type_uint32s_adjust(const f_array_length_t length, f_uint32s_t *uint32s) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_type_uint32s_adjust_) || !defined(_di_f_type_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_array_length_t length, f_uint32s_t *uint32s) F_attribute_visibility_internal_d;
+#endif // !defined(_di_f_uint32s_adjust_) || !defined(_di_f_uint32s_decimate_by_)
/**
* Private implementation for appending the uint32 array.
*
* Errors (with error bit) from: f_memory_resize().
*
- * @see f_type_uint32s_append()
- * @see f_type_uint32ss_append()
+ * @see f_uint32s_append()
+ * @see f_uint32ss_append()
*/
-#if !defined(_di_f_type_uint32s_append_) || !defined(_di_f_type_uint32ss_append_)
- extern f_status_t private_f_type_uint32s_append(const f_uint32s_t source, f_uint32s_t *destination) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_type_uint32s_append_) || !defined(_di_f_type_uint32ss_append_)
+#if !defined(_di_f_uint32s_append_) || !defined(_di_f_uint32ss_append_)
+ extern f_status_t private_f_uint32s_append(const f_uint32s_t source, f_uint32s_t *destination) F_attribute_visibility_internal_d;
+#endif // !defined(_di_f_uint32s_append_) || !defined(_di_f_uint32ss_append_)
/**
* Private implementation for resizing the uint32s array.
*
* Errors (with error bit) from: f_memory_resize().
*
- * @see f_type_uint32s_resize()
- * @see f_type_uint32s_append()
- * @see f_type_uint32s_decimate_by()
- * @see f_type_uint32ss_append()
+ * @see f_uint32s_resize()
+ * @see f_uint32s_append()
+ * @see f_uint32s_decimate_by()
+ * @see f_uint32ss_append()
*/
-#if !defined(_di_f_type_uint32s_resize_) || !defined(_di_f_type_uint32s_append_) || !defined(_di_f_type_uint32s_decimate_by_) || !defined(_di_f_type_uint32ss_append_)
- extern f_status_t private_f_type_uint32s_resize(const f_array_length_t length, f_uint32s_t *uint32s) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_type_uint32s_resize_) || !defined(_di_f_type_uint32s_append_) || !defined(_di_f_type_uint32s_decimate_by_) || !defined(_di_f_type_uint32ss_append_)
+#if !defined(_di_f_uint32s_resize_) || !defined(_di_f_uint32s_append_) || !defined(_di_f_uint32s_decimate_by_) || !defined(_di_f_uint32ss_append_)
+ extern f_status_t private_f_uint32s_resize(const f_array_length_t length, f_uint32s_t *uint32s) F_attribute_visibility_internal_d;
+#endif // !defined(_di_f_uint32s_resize_) || !defined(_di_f_uint32s_append_) || !defined(_di_f_uint32s_decimate_by_) || !defined(_di_f_uint32ss_append_)
/**
* Private implementation for resizing the uint32ss array.
* Errors (with error bit) from: f_memory_adjust().
* Errors (with error bit) from: f_memory_destroy().
*
- * @see f_type_uint32ss_adjust()
- * @see f_type_uint32ss_decimate_by()
+ * @see f_uint32ss_adjust()
+ * @see f_uint32ss_decimate_by()
*/
-#if !defined(_di_f_type_uint32ss_adjust_) || !defined(_di_f_type_uint32ss_decimate_by_)
- extern f_status_t private_f_type_uint32ss_adjust(const f_array_length_t length, f_uint32ss_t *uint32ss) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_type_uint32ss_adjust_) || !defined(_di_f_type_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_array_length_t length, f_uint32ss_t *uint32ss) F_attribute_visibility_internal_d;
+#endif // !defined(_di_f_uint32ss_adjust_) || !defined(_di_f_uint32ss_decimate_by_)
/**
* Private implementation for resizing the uint32ss array.
* Errors (with error bit) from: f_memory_delete().
* Errors (with error bit) from: f_memory_resize().
*
- * @see f_type_uint32ss_decrease_by()
- * @see f_type_uint32ss_increase()
- * @see f_type_uint32ss_increase_by()
- * @see f_type_uint32ss_resize()
+ * @see f_uint32ss_decrease_by()
+ * @see f_uint32ss_increase()
+ * @see f_uint32ss_increase_by()
+ * @see f_uint32ss_resize()
*/
-#if !defined(_di_f_type_uint32ss_decrease_by_) || !defined(_di_f_type_uint32ss_increase_) || !defined(_di_f_type_uint32ss_increase_by_) || !defined(_di_f_type_uint32ss_resize_)
- extern f_status_t private_f_type_uint32ss_resize(const f_array_length_t length, f_uint32ss_t *uint32ss) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_type_uint32ss_decrease_by_) || !defined(_di_f_type_uint32ss_increase_) || !defined(_di_f_type_uint32ss_increase_by_) || !defined(_di_f_type_uint32ss_resize_)
+#if !defined(_di_f_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_array_length_t length, f_uint32ss_t *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
} // extern "C"
extern "C" {
#endif
-#if !defined(_di_f_type_int64s_adjust_) || !defined(_di_f_type_int64s_decimate_by_)
- f_status_t private_f_type_int64s_adjust(const f_array_length_t length, f_int64s_t *int64s) {
+#if !defined(_di_f_int64s_adjust_) || !defined(_di_f_int64s_decimate_by_)
+ f_status_t private_f_int64s_adjust(const f_array_length_t length, f_int64s_t *int64s) {
const f_status_t status = f_memory_adjust(int64s->size, length, sizeof(int64_t), (void **) & int64s->array);
return status;
}
-#endif // !defined(_di_f_type_int64s_adjust_) || !defined(_di_f_type_int64s_decimate_by_)
+#endif // !defined(_di_f_int64s_adjust_) || !defined(_di_f_int64s_decimate_by_)
-#if !defined(_di_f_type_int64s_append_) || !defined(_di_f_type_int64ss_append_)
- extern f_status_t private_f_type_int64s_append(const f_int64s_t source, f_int64s_t *destination) {
+#if !defined(_di_f_int64s_append_) || !defined(_di_f_int64ss_append_)
+ extern f_status_t private_f_int64s_append(const f_int64s_t source, f_int64s_t *destination) {
f_status_t status = F_none;
if (destination->used + source.used > destination->size) {
- status = private_f_type_int64s_adjust(destination->used + source.used, destination);
+ status = private_f_int64s_adjust(destination->used + source.used, destination);
if (F_status_is_error(status)) return status;
}
return F_none;
}
-#endif // !defined(_di_f_type_int64s_append_) || !defined(_di_f_type_int64ss_append_)
+#endif // !defined(_di_f_int64s_append_) || !defined(_di_f_int64ss_append_)
-#if !defined(_di_f_type_int64s_resize_) || !defined(_di_f_type_int64s_append_) || !defined(_di_f_type_int64s_decimate_by_) || !defined(_di_f_type_int64ss_append_)
- f_status_t private_f_type_int64s_resize(const f_array_length_t length, f_int64s_t *int64s) {
+#if !defined(_di_f_int64s_resize_) || !defined(_di_f_int64s_append_) || !defined(_di_f_int64s_decimate_by_) || !defined(_di_f_int64ss_append_)
+ f_status_t private_f_int64s_resize(const f_array_length_t length, f_int64s_t *int64s) {
const f_status_t status = f_memory_resize(int64s->size, length, sizeof(int64_t), (void **) & int64s->array);
return status;
}
-#endif // !defined(_di_f_type_int64s_resize_) || !defined(_di_f_type_int64s_append_) || !defined(_di_f_type_int64s_decimate_by_) || !defined(_di_f_type_int64ss_append_)
+#endif // !defined(_di_f_int64s_resize_) || !defined(_di_f_int64s_append_) || !defined(_di_f_int64s_decimate_by_) || !defined(_di_f_int64ss_append_)
-#if !defined(_di_f_type_int64ss_adjust_) || !defined(_di_f_type_int64ss_decimate_by_)
- f_status_t private_f_type_int64ss_adjust(const f_array_length_t length, f_int64ss_t *int64ss) {
+#if !defined(_di_f_int64ss_adjust_) || !defined(_di_f_int64ss_decimate_by_)
+ f_status_t private_f_int64ss_adjust(const f_array_length_t length, f_int64ss_t *int64ss) {
f_status_t status = F_none;
return status;
}
-#endif // !defined(_di_f_type_int64ss_adjust_) || !defined(_di_f_type_int64ss_decimate_by_)
+#endif // !defined(_di_f_int64ss_adjust_) || !defined(_di_f_int64ss_decimate_by_)
-#if !defined(_di_f_type_int64ss_decrease_by_) || !defined(_di_f_type_int64ss_increase_) || !defined(_di_f_type_int64ss_increase_by_) || !defined(_di_f_type_int64ss_resize_)
- f_status_t private_f_type_int64ss_resize(const f_array_length_t length, f_int64ss_t *int64ss) {
+#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_array_length_t length, f_int64ss_t *int64ss) {
f_status_t status = F_none;
return status;
}
-#endif // !defined(_di_f_type_int64ss_decrease_by_) || !defined(_di_f_type_int64ss_increase_) || !defined(_di_f_type_int64ss_increase_by_) || !defined(_di_f_type_int64ss_resize_)
+#endif // !defined(_di_f_int64ss_decrease_by_) || !defined(_di_f_int64ss_increase_) || !defined(_di_f_int64ss_increase_by_) || !defined(_di_f_int64ss_resize_)
-#if !defined(_di_f_type_uint64s_adjust_) || !defined(_di_f_type_uint64s_decimate_by_)
- f_status_t private_f_type_uint64s_adjust(const f_array_length_t length, f_uint64s_t *uint64s) {
+#if !defined(_di_f_uint64s_adjust_) || !defined(_di_f_uint64s_decimate_by_)
+ f_status_t private_f_uint64s_adjust(const f_array_length_t length, f_uint64s_t *uint64s) {
const f_status_t status = f_memory_adjust(uint64s->size, length, sizeof(uint64_t), (void **) & uint64s->array);
return status;
}
-#endif // !defined(_di_f_type_uint64s_adjust_) || !defined(_di_f_type_uint64s_decimate_by_)
+#endif // !defined(_di_f_uint64s_adjust_) || !defined(_di_f_uint64s_decimate_by_)
-#if !defined(_di_f_type_uint64s_append_) || !defined(_di_f_type_uint64ss_append_)
- extern f_status_t private_f_type_uint64s_append(const f_uint64s_t source, f_uint64s_t *destination) {
+#if !defined(_di_f_uint64s_append_) || !defined(_di_f_uint64ss_append_)
+ extern f_status_t private_f_uint64s_append(const f_uint64s_t source, f_uint64s_t *destination) {
f_status_t status = F_none;
if (destination->used + source.used > destination->size) {
- status = private_f_type_uint64s_adjust(destination->used + source.used, destination);
+ status = private_f_uint64s_adjust(destination->used + source.used, destination);
if (F_status_is_error(status)) return status;
}
return F_none;
}
-#endif // !defined(_di_f_type_uint64s_append_) || !defined(_di_f_type_uint64ss_append_)
+#endif // !defined(_di_f_uint64s_append_) || !defined(_di_f_uint64ss_append_)
-#if !defined(_di_f_type_uint64s_resize_) || !defined(_di_f_type_uint64s_append_) || !defined(_di_f_type_uint64s_decimate_by_) || !defined(_di_f_type_uint64ss_append_)
- f_status_t private_f_type_uint64s_resize(const f_array_length_t length, f_uint64s_t *uint64s) {
+#if !defined(_di_f_uint64s_resize_) || !defined(_di_f_uint64s_append_) || !defined(_di_f_uint64s_decimate_by_) || !defined(_di_f_uint64ss_append_)
+ f_status_t private_f_uint64s_resize(const f_array_length_t length, f_uint64s_t *uint64s) {
const f_status_t status = f_memory_resize(uint64s->size, length, sizeof(uint64_t), (void **) & uint64s->array);
return status;
}
-#endif // !defined(_di_f_type_uint64s_resize_) || !defined(_di_f_type_uint64s_append_) || !defined(_di_f_type_uint64s_decimate_by_) || !defined(_di_f_type_uint64ss_append_)
+#endif // !defined(_di_f_uint64s_resize_) || !defined(_di_f_uint64s_append_) || !defined(_di_f_uint64s_decimate_by_) || !defined(_di_f_uint64ss_append_)
-#if !defined(_di_f_type_uint64ss_adjust_) || !defined(_di_f_type_uint64ss_decimate_by_)
- f_status_t private_f_type_uint64ss_adjust(const f_array_length_t length, f_uint64ss_t *uint64ss) {
+#if !defined(_di_f_uint64ss_adjust_) || !defined(_di_f_uint64ss_decimate_by_)
+ f_status_t private_f_uint64ss_adjust(const f_array_length_t length, f_uint64ss_t *uint64ss) {
f_status_t status = F_none;
return status;
}
-#endif // !defined(_di_f_type_uint64ss_adjust_) || !defined(_di_f_type_uint64ss_decimate_by_)
+#endif // !defined(_di_f_uint64ss_adjust_) || !defined(_di_f_uint64ss_decimate_by_)
-#if !defined(_di_f_type_uint64ss_decrease_by_) || !defined(_di_f_type_uint64ss_increase_) || !defined(_di_f_type_uint64ss_increase_by_) || !defined(_di_f_type_uint64ss_resize_)
- f_status_t private_f_type_uint64ss_resize(const f_array_length_t length, f_uint64ss_t *uint64ss) {
+#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_array_length_t length, f_uint64ss_t *uint64ss) {
f_status_t status = F_none;
return status;
}
-#endif // !defined(_di_f_type_uint64ss_decrease_by_) || !defined(_di_f_type_uint64ss_increase_) || !defined(_di_f_type_uint64ss_increase_by_) || !defined(_di_f_type_uint64ss_resize_)
+#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
} // extern "C"
*
* Errors (with error bit) from: f_memory_adjust().
*
- * @see f_type_int64s_adjust()
- * @see f_type_int64s_decimate_by()
+ * @see f_int64s_adjust()
+ * @see f_int64s_decimate_by()
*/
-#if !defined(_di_f_type_int64s_adjust_) || !defined(_di_f_type_int64s_decimate_by_)
- extern f_status_t private_f_type_int64s_adjust(const f_array_length_t length, f_int64s_t *int64s) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_type_int64s_adjust_) || !defined(_di_f_type_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_array_length_t length, f_int64s_t *int64s) F_attribute_visibility_internal_d;
+#endif // !defined(_di_f_int64s_adjust_) || !defined(_di_f_int64s_decimate_by_)
/**
* Private implementation for appending the int64 array.
*
* Errors (with error bit) from: f_memory_resize().
*
- * @see f_type_int64s_append()
- * @see f_type_int64ss_append()
+ * @see f_int64s_append()
+ * @see f_int64ss_append()
*/
-#if !defined(_di_f_type_int64s_append_) || !defined(_di_f_type_int64ss_append_)
- extern f_status_t private_f_type_int64s_append(const f_int64s_t source, f_int64s_t *destination) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_type_int64s_append_) || !defined(_di_f_type_int64ss_append_)
+#if !defined(_di_f_int64s_append_) || !defined(_di_f_int64ss_append_)
+ extern f_status_t private_f_int64s_append(const f_int64s_t source, f_int64s_t *destination) F_attribute_visibility_internal_d;
+#endif // !defined(_di_f_int64s_append_) || !defined(_di_f_int64ss_append_)
/**
* Private implementation for resizing the int64s array.
*
* Errors (with error bit) from: f_memory_resize().
*
- * @see f_type_int64s_resize()
- * @see f_type_int64s_append()
- * @see f_type_int64s_decimate_by()
- * @see f_type_int64ss_append()
+ * @see f_int64s_resize()
+ * @see f_int64s_append()
+ * @see f_int64s_decimate_by()
+ * @see f_int64ss_append()
*/
-#if !defined(_di_f_type_int64s_resize_) || !defined(_di_f_type_int64s_append_) || !defined(_di_f_type_int64s_decimate_by_) || !defined(_di_f_type_int64ss_append_)
- extern f_status_t private_f_type_int64s_resize(const f_array_length_t length, f_int64s_t *int64s) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_type_int64s_resize_) || !defined(_di_f_type_int64s_append_) || !defined(_di_f_type_int64s_decimate_by_) || !defined(_di_f_type_int64ss_append_)
+#if !defined(_di_f_int64s_resize_) || !defined(_di_f_int64s_append_) || !defined(_di_f_int64s_decimate_by_) || !defined(_di_f_int64ss_append_)
+ extern f_status_t private_f_int64s_resize(const f_array_length_t length, f_int64s_t *int64s) F_attribute_visibility_internal_d;
+#endif // !defined(_di_f_int64s_resize_) || !defined(_di_f_int64s_append_) || !defined(_di_f_int64s_decimate_by_) || !defined(_di_f_int64ss_append_)
/**
* Private implementation for resizing the int64ss array.
* Errors (with error bit) from: f_memory_adjust().
* Errors (with error bit) from: f_memory_destroy().
*
- * @see f_type_int64ss_adjust()
- * @see f_type_int64ss_decimate_by()
+ * @see f_int64ss_adjust()
+ * @see f_int64ss_decimate_by()
*/
-#if !defined(_di_f_type_int64ss_adjust_) || !defined(_di_f_type_int64ss_decimate_by_)
- extern f_status_t private_f_type_int64ss_adjust(const f_array_length_t length, f_int64ss_t *int64ss) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_type_int64ss_adjust_) || !defined(_di_f_type_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_array_length_t length, f_int64ss_t *int64ss) F_attribute_visibility_internal_d;
+#endif // !defined(_di_f_int64ss_adjust_) || !defined(_di_f_int64ss_decimate_by_)
/**
* Private implementation for resizing the int64ss array.
* Errors (with error bit) from: f_memory_delete().
* Errors (with error bit) from: f_memory_resize().
*
- * @see f_type_int64ss_decrease_by()
- * @see f_type_int64ss_increase()
- * @see f_type_int64ss_increase_by()
- * @see f_type_int64ss_resize()
+ * @see f_int64ss_decrease_by()
+ * @see f_int64ss_increase()
+ * @see f_int64ss_increase_by()
+ * @see f_int64ss_resize()
*/
-#if !defined(_di_f_type_int64ss_decrease_by_) || !defined(_di_f_type_int64ss_increase_) || !defined(_di_f_type_int64ss_increase_by_) || !defined(_di_f_type_int64ss_resize_)
- extern f_status_t private_f_type_int64ss_resize(const f_array_length_t length, f_int64ss_t *int64ss) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_type_int64ss_decrease_by_) || !defined(_di_f_type_int64ss_increase_) || !defined(_di_f_type_int64ss_increase_by_) || !defined(_di_f_type_int64ss_resize_)
+#if !defined(_di_f_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_array_length_t length, f_int64ss_t *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_)
/**
* Private implementation for resizing the uint64s array.
*
* Errors (with error bit) from: f_memory_adjust().
*
- * @see f_type_uint64s_adjust()
- * @see f_type_uint64s_decimate_by()
+ * @see f_uint64s_adjust()
+ * @see f_uint64s_decimate_by()
*/
-#if !defined(_di_f_type_uint64s_adjust_) || !defined(_di_f_type_uint64s_decimate_by_)
- extern f_status_t private_f_type_uint64s_adjust(const f_array_length_t length, f_uint64s_t *uint64s) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_type_uint64s_adjust_) || !defined(_di_f_type_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_array_length_t length, f_uint64s_t *uint64s) F_attribute_visibility_internal_d;
+#endif // !defined(_di_f_uint64s_adjust_) || !defined(_di_f_uint64s_decimate_by_)
/**
* Private implementation for appending the uint64 array.
*
* Errors (with error bit) from: f_memory_resize().
*
- * @see f_type_uint64s_append()
- * @see f_type_uint64ss_append()
+ * @see f_uint64s_append()
+ * @see f_uint64ss_append()
*/
-#if !defined(_di_f_type_uint64s_append_) || !defined(_di_f_type_uint64ss_append_)
- extern f_status_t private_f_type_uint64s_append(const f_uint64s_t source, f_uint64s_t *destination) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_type_uint64s_append_) || !defined(_di_f_type_uint64ss_append_)
+#if !defined(_di_f_uint64s_append_) || !defined(_di_f_uint64ss_append_)
+ extern f_status_t private_f_uint64s_append(const f_uint64s_t source, f_uint64s_t *destination) F_attribute_visibility_internal_d;
+#endif // !defined(_di_f_uint64s_append_) || !defined(_di_f_uint64ss_append_)
/**
* Private implementation for resizing the uint64s array.
*
* Errors (with error bit) from: f_memory_resize().
*
- * @see f_type_uint64s_resize()
- * @see f_type_uint64s_append()
- * @see f_type_uint64s_decimate_by()
- * @see f_type_uint64ss_append()
+ * @see f_uint64s_resize()
+ * @see f_uint64s_append()
+ * @see f_uint64s_decimate_by()
+ * @see f_uint64ss_append()
*/
-#if !defined(_di_f_type_uint64s_resize_) || !defined(_di_f_type_uint64s_append_) || !defined(_di_f_type_uint64s_decimate_by_) || !defined(_di_f_type_uint64ss_append_)
- extern f_status_t private_f_type_uint64s_resize(const f_array_length_t length, f_uint64s_t *uint64s) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_type_uint64s_resize_) || !defined(_di_f_type_uint64s_append_) || !defined(_di_f_type_uint64s_decimate_by_) || !defined(_di_f_type_uint64ss_append_)
+#if !defined(_di_f_uint64s_resize_) || !defined(_di_f_uint64s_append_) || !defined(_di_f_uint64s_decimate_by_) || !defined(_di_f_uint64ss_append_)
+ extern f_status_t private_f_uint64s_resize(const f_array_length_t length, f_uint64s_t *uint64s) F_attribute_visibility_internal_d;
+#endif // !defined(_di_f_uint64s_resize_) || !defined(_di_f_uint64s_append_) || !defined(_di_f_uint64s_decimate_by_) || !defined(_di_f_uint64ss_append_)
/**
* Private implementation for resizing the uint64ss array.
* Errors (with error bit) from: f_memory_adjust().
* Errors (with error bit) from: f_memory_destroy().
*
- * @see f_type_uint64ss_adjust()
- * @see f_type_uint64ss_decimate_by()
+ * @see f_uint64ss_adjust()
+ * @see f_uint64ss_decimate_by()
*/
-#if !defined(_di_f_type_uint64ss_adjust_) || !defined(_di_f_type_uint64ss_decimate_by_)
- extern f_status_t private_f_type_uint64ss_adjust(const f_array_length_t length, f_uint64ss_t *uint64ss) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_type_uint64ss_adjust_) || !defined(_di_f_type_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_array_length_t length, f_uint64ss_t *uint64ss) F_attribute_visibility_internal_d;
+#endif // !defined(_di_f_uint64ss_adjust_) || !defined(_di_f_uint64ss_decimate_by_)
/**
* Private implementation for resizing the uint64ss array.
* Errors (with error bit) from: f_memory_delete().
* Errors (with error bit) from: f_memory_resize().
*
- * @see f_type_uint64ss_decrease_by()
- * @see f_type_uint64ss_increase()
- * @see f_type_uint64ss_increase_by()
- * @see f_type_uint64ss_resize()
+ * @see f_uint64ss_decrease_by()
+ * @see f_uint64ss_increase()
+ * @see f_uint64ss_increase_by()
+ * @see f_uint64ss_resize()
*/
-#if !defined(_di_f_type_uint64ss_decrease_by_) || !defined(_di_f_type_uint64ss_increase_) || !defined(_di_f_type_uint64ss_increase_by_) || !defined(_di_f_type_uint64ss_resize_)
- extern f_status_t private_f_type_uint64ss_resize(const f_array_length_t length, f_uint64ss_t *uint64ss) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_type_uint64ss_decrease_by_) || !defined(_di_f_type_uint64ss_increase_) || !defined(_di_f_type_uint64ss_increase_by_) || !defined(_di_f_type_uint64ss_resize_)
+#if !defined(_di_f_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_array_length_t length, f_uint64ss_t *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
} // extern "C"
extern "C" {
#endif
-#if !defined(_di_f_type_int8s_adjust_) || !defined(_di_f_type_int8s_decimate_by_)
- f_status_t private_f_type_int8s_adjust(const f_array_length_t length, f_int8s_t *int8s) {
+#if !defined(_di_f_int8s_adjust_) || !defined(_di_f_int8s_decimate_by_)
+ f_status_t private_f_int8s_adjust(const f_array_length_t length, f_int8s_t *int8s) {
const f_status_t status = f_memory_adjust(int8s->size, length, sizeof(int8_t), (void **) & int8s->array);
return status;
}
-#endif // !defined(_di_f_type_int8s_adjust_) || !defined(_di_f_type_int8s_decimate_by_)
+#endif // !defined(_di_f_int8s_adjust_) || !defined(_di_f_int8s_decimate_by_)
-#if !defined(_di_f_type_int8s_append_) || !defined(_di_f_type_int8ss_append_)
- extern f_status_t private_f_type_int8s_append(const f_int8s_t source, f_int8s_t *destination) {
+#if !defined(_di_f_int8s_append_) || !defined(_di_f_int8ss_append_)
+ extern f_status_t private_f_int8s_append(const f_int8s_t source, f_int8s_t *destination) {
f_status_t status = F_none;
if (destination->used + source.used > destination->size) {
- status = private_f_type_int8s_adjust(destination->used + source.used, destination);
+ status = private_f_int8s_adjust(destination->used + source.used, destination);
if (F_status_is_error(status)) return status;
}
return F_none;
}
-#endif // !defined(_di_f_type_int8s_append_) || !defined(_di_f_type_int8ss_append_)
+#endif // !defined(_di_f_int8s_append_) || !defined(_di_f_int8ss_append_)
-#if !defined(_di_f_type_int8s_resize_) || !defined(_di_f_type_int8s_append_) || !defined(_di_f_type_int8s_decimate_by_) || !defined(_di_f_type_int8ss_append_)
- f_status_t private_f_type_int8s_resize(const f_array_length_t length, f_int8s_t *int8s) {
+#if !defined(_di_f_int8s_resize_) || !defined(_di_f_int8s_append_) || !defined(_di_f_int8s_decimate_by_) || !defined(_di_f_int8ss_append_)
+ f_status_t private_f_int8s_resize(const f_array_length_t length, f_int8s_t *int8s) {
const f_status_t status = f_memory_resize(int8s->size, length, sizeof(int8_t), (void **) & int8s->array);
return status;
}
-#endif // !defined(_di_f_type_int8s_resize_) || !defined(_di_f_type_int8s_append_) || !defined(_di_f_type_int8s_decimate_by_) || !defined(_di_f_type_int8ss_append_)
+#endif // !defined(_di_f_int8s_resize_) || !defined(_di_f_int8s_append_) || !defined(_di_f_int8s_decimate_by_) || !defined(_di_f_int8ss_append_)
-#if !defined(_di_f_type_int8ss_adjust_) || !defined(_di_f_type_int8ss_decimate_by_)
- f_status_t private_f_type_int8ss_adjust(const f_array_length_t length, f_int8ss_t *int8ss) {
+#if !defined(_di_f_int8ss_adjust_) || !defined(_di_f_int8ss_decimate_by_)
+ f_status_t private_f_int8ss_adjust(const f_array_length_t length, f_int8ss_t *int8ss) {
f_status_t status = F_none;
return status;
}
-#endif // !defined(_di_f_type_int8ss_adjust_) || !defined(_di_f_type_int8ss_decimate_by_)
+#endif // !defined(_di_f_int8ss_adjust_) || !defined(_di_f_int8ss_decimate_by_)
-#if !defined(_di_f_type_int8ss_decrease_by_) || !defined(_di_f_type_int8ss_increase_) || !defined(_di_f_type_int8ss_increase_by_) || !defined(_di_f_type_int8ss_resize_)
- f_status_t private_f_type_int8ss_resize(const f_array_length_t length, f_int8ss_t *int8ss) {
+#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_array_length_t length, f_int8ss_t *int8ss) {
f_status_t status = F_none;
return status;
}
-#endif // !defined(_di_f_type_int8ss_decrease_by_) || !defined(_di_f_type_int8ss_increase_) || !defined(_di_f_type_int8ss_increase_by_) || !defined(_di_f_type_int8ss_resize_)
+#endif // !defined(_di_f_int8ss_decrease_by_) || !defined(_di_f_int8ss_increase_) || !defined(_di_f_int8ss_increase_by_) || !defined(_di_f_int8ss_resize_)
-#if !defined(_di_f_type_uint8s_adjust_) || !defined(_di_f_type_uint8s_decimate_by_)
- f_status_t private_f_type_uint8s_adjust(const f_array_length_t length, f_uint8s_t *uint8s) {
+#if !defined(_di_f_uint8s_adjust_) || !defined(_di_f_uint8s_decimate_by_)
+ f_status_t private_f_uint8s_adjust(const f_array_length_t length, f_uint8s_t *uint8s) {
const f_status_t status = f_memory_adjust(uint8s->size, length, sizeof(uint8_t), (void **) & uint8s->array);
return status;
}
-#endif // !defined(_di_f_type_uint8s_adjust_) || !defined(_di_f_type_uint8s_decimate_by_)
+#endif // !defined(_di_f_uint8s_adjust_) || !defined(_di_f_uint8s_decimate_by_)
-#if !defined(_di_f_type_uint8s_append_) || !defined(_di_f_type_uint8ss_append_)
- extern f_status_t private_f_type_uint8s_append(const f_uint8s_t source, f_uint8s_t *destination) {
+#if !defined(_di_f_uint8s_append_) || !defined(_di_f_uint8ss_append_)
+ extern f_status_t private_f_uint8s_append(const f_uint8s_t source, f_uint8s_t *destination) {
f_status_t status = F_none;
if (destination->used + source.used > destination->size) {
- status = private_f_type_uint8s_adjust(destination->used + source.used, destination);
+ status = private_f_uint8s_adjust(destination->used + source.used, destination);
if (F_status_is_error(status)) return status;
}
return F_none;
}
-#endif // !defined(_di_f_type_uint8s_append_) || !defined(_di_f_type_uint8ss_append_)
+#endif // !defined(_di_f_uint8s_append_) || !defined(_di_f_uint8ss_append_)
-#if !defined(_di_f_type_uint8s_resize_) || !defined(_di_f_type_uint8s_append_) || !defined(_di_f_type_uint8s_decimate_by_) || !defined(_di_f_type_uint8ss_append_)
- f_status_t private_f_type_uint8s_resize(const f_array_length_t length, f_uint8s_t *uint8s) {
+#if !defined(_di_f_uint8s_resize_) || !defined(_di_f_uint8s_append_) || !defined(_di_f_uint8s_decimate_by_) || !defined(_di_f_uint8ss_append_)
+ f_status_t private_f_uint8s_resize(const f_array_length_t length, f_uint8s_t *uint8s) {
const f_status_t status = f_memory_resize(uint8s->size, length, sizeof(uint8_t), (void **) & uint8s->array);
return status;
}
-#endif // !defined(_di_f_type_uint8s_resize_) || !defined(_di_f_type_uint8s_append_) || !defined(_di_f_type_uint8s_decimate_by_) || !defined(_di_f_type_uint8ss_append_)
+#endif // !defined(_di_f_uint8s_resize_) || !defined(_di_f_uint8s_append_) || !defined(_di_f_uint8s_decimate_by_) || !defined(_di_f_uint8ss_append_)
-#if !defined(_di_f_type_uint8ss_adjust_) || !defined(_di_f_type_uint8ss_decimate_by_)
- f_status_t private_f_type_uint8ss_adjust(const f_array_length_t length, f_uint8ss_t *uint8ss) {
+#if !defined(_di_f_uint8ss_adjust_) || !defined(_di_f_uint8ss_decimate_by_)
+ f_status_t private_f_uint8ss_adjust(const f_array_length_t length, f_uint8ss_t *uint8ss) {
f_status_t status = F_none;
return status;
}
-#endif // !defined(_di_f_type_uint8ss_adjust_) || !defined(_di_f_type_uint8ss_decimate_by_)
+#endif // !defined(_di_f_uint8ss_adjust_) || !defined(_di_f_uint8ss_decimate_by_)
-#if !defined(_di_f_type_uint8ss_decrease_by_) || !defined(_di_f_type_uint8ss_increase_) || !defined(_di_f_type_uint8ss_increase_by_) || !defined(_di_f_type_uint8ss_resize_)
- f_status_t private_f_type_uint8ss_resize(const f_array_length_t length, f_uint8ss_t *uint8ss) {
+#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_array_length_t length, f_uint8ss_t *uint8ss) {
f_status_t status = F_none;
return status;
}
-#endif // !defined(_di_f_type_uint8ss_decrease_by_) || !defined(_di_f_type_uint8ss_increase_) || !defined(_di_f_type_uint8ss_increase_by_) || !defined(_di_f_type_uint8ss_resize_)
+#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
} // extern "C"
*
* Errors (with error bit) from: f_memory_adjust().
*
- * @see f_type_int8s_adjust()
- * @see f_type_int8s_decimate_by()
+ * @see f_int8s_adjust()
+ * @see f_int8s_decimate_by()
*/
-#if !defined(_di_f_type_int8s_adjust_) || !defined(_di_f_type_int8s_decimate_by_)
- extern f_status_t private_f_type_int8s_adjust(const f_array_length_t length, f_int8s_t *int8s) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_type_int8s_adjust_) || !defined(_di_f_type_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_array_length_t length, f_int8s_t *int8s) F_attribute_visibility_internal_d;
+#endif // !defined(_di_f_int8s_adjust_) || !defined(_di_f_int8s_decimate_by_)
/**
* Private implementation for appending the int8 array.
*
* Errors (with error bit) from: f_memory_resize().
*
- * @see f_type_int8s_append()
- * @see f_type_int8ss_append()
+ * @see f_int8s_append()
+ * @see f_int8ss_append()
*/
-#if !defined(_di_f_type_int8s_append_) || !defined(_di_f_type_int8ss_append_)
- extern f_status_t private_f_type_int8s_append(const f_int8s_t source, f_int8s_t *destination) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_type_int8s_append_) || !defined(_di_f_type_int8ss_append_)
+#if !defined(_di_f_int8s_append_) || !defined(_di_f_int8ss_append_)
+ extern f_status_t private_f_int8s_append(const f_int8s_t source, f_int8s_t *destination) F_attribute_visibility_internal_d;
+#endif // !defined(_di_f_int8s_append_) || !defined(_di_f_int8ss_append_)
/**
* Private implementation for resizing the int8s array.
*
* Errors (with error bit) from: f_memory_resize().
*
- * @see f_type_int8s_resize()
- * @see f_type_int8s_append()
- * @see f_type_int8s_decimate_by()
- * @see f_type_int8ss_append()
+ * @see f_int8s_resize()
+ * @see f_int8s_append()
+ * @see f_int8s_decimate_by()
+ * @see f_int8ss_append()
*/
-#if !defined(_di_f_type_int8s_resize_) || !defined(_di_f_type_int8s_append_) || !defined(_di_f_type_int8s_decimate_by_) || !defined(_di_f_type_int8ss_append_)
- extern f_status_t private_f_type_int8s_resize(const f_array_length_t length, f_int8s_t *int8s) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_type_int8s_resize_) || !defined(_di_f_type_int8s_append_) || !defined(_di_f_type_int8s_decimate_by_) || !defined(_di_f_type_int8ss_append_)
+#if !defined(_di_f_int8s_resize_) || !defined(_di_f_int8s_append_) || !defined(_di_f_int8s_decimate_by_) || !defined(_di_f_int8ss_append_)
+ extern f_status_t private_f_int8s_resize(const f_array_length_t length, f_int8s_t *int8s) F_attribute_visibility_internal_d;
+#endif // !defined(_di_f_int8s_resize_) || !defined(_di_f_int8s_append_) || !defined(_di_f_int8s_decimate_by_) || !defined(_di_f_int8ss_append_)
/**
* Private implementation for resizing the int8ss array.
* Errors (with error bit) from: f_memory_adjust().
* Errors (with error bit) from: f_memory_destroy().
*
- * @see f_type_int8ss_adjust()
- * @see f_type_int8ss_decimate_by()
+ * @see f_int8ss_adjust()
+ * @see f_int8ss_decimate_by()
*/
-#if !defined(_di_f_type_int8ss_adjust_) || !defined(_di_f_type_int8ss_decimate_by_)
- extern f_status_t private_f_type_int8ss_adjust(const f_array_length_t length, f_int8ss_t *int8ss) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_type_int8ss_adjust_) || !defined(_di_f_type_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_array_length_t length, f_int8ss_t *int8ss) F_attribute_visibility_internal_d;
+#endif // !defined(_di_f_int8ss_adjust_) || !defined(_di_f_int8ss_decimate_by_)
/**
* Private implementation for resizing the int8ss array.
* Errors (with error bit) from: f_memory_delete().
* Errors (with error bit) from: f_memory_resize().
*
- * @see f_type_int8ss_decrease_by()
- * @see f_type_int8ss_increase()
- * @see f_type_int8ss_increase_by()
- * @see f_type_int8ss_resize()
+ * @see f_int8ss_decrease_by()
+ * @see f_int8ss_increase()
+ * @see f_int8ss_increase_by()
+ * @see f_int8ss_resize()
*/
-#if !defined(_di_f_type_int8ss_decrease_by_) || !defined(_di_f_type_int8ss_increase_) || !defined(_di_f_type_int8ss_increase_by_) || !defined(_di_f_type_int8ss_resize_)
- extern f_status_t private_f_type_int8ss_resize(const f_array_length_t length, f_int8ss_t *int8ss) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_type_int8ss_decrease_by_) || !defined(_di_f_type_int8ss_increase_) || !defined(_di_f_type_int8ss_increase_by_) || !defined(_di_f_type_int8ss_resize_)
+#if !defined(_di_f_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_array_length_t length, f_int8ss_t *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_)
/**
* Private implementation for resizing the uint8s array.
*
* Errors (with error bit) from: f_memory_adjust().
*
- * @see f_type_uint8s_adjust()
- * @see f_type_uint8s_decimate_by()
+ * @see f_uint8s_adjust()
+ * @see f_uint8s_decimate_by()
*/
-#if !defined(_di_f_type_uint8s_adjust_) || !defined(_di_f_type_uint8s_decimate_by_)
- extern f_status_t private_f_type_uint8s_adjust(const f_array_length_t length, f_uint8s_t *uint8s) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_type_uint8s_adjust_) || !defined(_di_f_type_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_array_length_t length, f_uint8s_t *uint8s) F_attribute_visibility_internal_d;
+#endif // !defined(_di_f_uint8s_adjust_) || !defined(_di_f_uint8s_decimate_by_)
/**
* Private implementation for appending the uint8 array.
*
* Errors (with error bit) from: f_memory_resize().
*
- * @see f_type_uint8s_append()
- * @see f_type_uint8ss_append()
+ * @see f_uint8s_append()
+ * @see f_uint8ss_append()
*/
-#if !defined(_di_f_type_uint8s_append_) || !defined(_di_f_type_uint8ss_append_)
- extern f_status_t private_f_type_uint8s_append(const f_uint8s_t source, f_uint8s_t *destination) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_type_uint8s_append_) || !defined(_di_f_type_uint8ss_append_)
+#if !defined(_di_f_uint8s_append_) || !defined(_di_f_uint8ss_append_)
+ extern f_status_t private_f_uint8s_append(const f_uint8s_t source, f_uint8s_t *destination) F_attribute_visibility_internal_d;
+#endif // !defined(_di_f_uint8s_append_) || !defined(_di_f_uint8ss_append_)
/**
* Private implementation for resizing the uint8s array.
*
* Errors (with error bit) from: f_memory_resize().
*
- * @see f_type_uint8s_resize()
- * @see f_type_uint8s_append()
- * @see f_type_uint8s_decimate_by()
- * @see f_type_uint8ss_append()
+ * @see f_uint8s_resize()
+ * @see f_uint8s_append()
+ * @see f_uint8s_decimate_by()
+ * @see f_uint8ss_append()
*/
-#if !defined(_di_f_type_uint8s_resize_) || !defined(_di_f_type_uint8s_append_) || !defined(_di_f_type_uint8s_decimate_by_) || !defined(_di_f_type_uint8ss_append_)
- extern f_status_t private_f_type_uint8s_resize(const f_array_length_t length, f_uint8s_t *uint8s) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_type_uint8s_resize_) || !defined(_di_f_type_uint8s_append_) || !defined(_di_f_type_uint8s_decimate_by_) || !defined(_di_f_type_uint8ss_append_)
+#if !defined(_di_f_uint8s_resize_) || !defined(_di_f_uint8s_append_) || !defined(_di_f_uint8s_decimate_by_) || !defined(_di_f_uint8ss_append_)
+ extern f_status_t private_f_uint8s_resize(const f_array_length_t length, f_uint8s_t *uint8s) F_attribute_visibility_internal_d;
+#endif // !defined(_di_f_uint8s_resize_) || !defined(_di_f_uint8s_append_) || !defined(_di_f_uint8s_decimate_by_) || !defined(_di_f_uint8ss_append_)
/**
* Private implementation for resizing the uint8ss array.
* Errors (with error bit) from: f_memory_adjust().
* Errors (with error bit) from: f_memory_destroy().
*
- * @see f_type_uint8ss_adjust()
- * @see f_type_uint8ss_decimate_by()
+ * @see f_uint8ss_adjust()
+ * @see f_uint8ss_decimate_by()
*/
-#if !defined(_di_f_type_uint8ss_adjust_) || !defined(_di_f_type_uint8ss_decimate_by_)
- extern f_status_t private_f_type_uint8ss_adjust(const f_array_length_t length, f_uint8ss_t *uint8ss) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_type_uint8ss_adjust_) || !defined(_di_f_type_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_array_length_t length, f_uint8ss_t *uint8ss) F_attribute_visibility_internal_d;
+#endif // !defined(_di_f_uint8ss_adjust_) || !defined(_di_f_uint8ss_decimate_by_)
/**
* Private implementation for resizing the uint8ss array.
* Errors (with error bit) from: f_memory_delete().
* Errors (with error bit) from: f_memory_resize().
*
- * @see f_type_uint8ss_decrease_by()
- * @see f_type_uint8ss_increase()
- * @see f_type_uint8ss_increase_by()
- * @see f_type_uint8ss_resize()
+ * @see f_uint8ss_decrease_by()
+ * @see f_uint8ss_increase()
+ * @see f_uint8ss_increase_by()
+ * @see f_uint8ss_resize()
*/
-#if !defined(_di_f_type_uint8ss_decrease_by_) || !defined(_di_f_type_uint8ss_increase_) || !defined(_di_f_type_uint8ss_increase_by_) || !defined(_di_f_type_uint8ss_resize_)
- extern f_status_t private_f_type_uint8ss_resize(const f_array_length_t length, f_uint8ss_t *uint8ss) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_type_uint8ss_decrease_by_) || !defined(_di_f_type_uint8ss_increase_) || !defined(_di_f_type_uint8ss_increase_by_) || !defined(_di_f_type_uint8ss_resize_)
+#if !defined(_di_f_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_array_length_t length, f_uint8ss_t *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
} // extern "C"
extern "C" {
#endif
-#if !defined(_di_f_type_states_adjust_) || !defined(_di_f_type_states_decimate_by_)
- f_status_t private_f_type_states_adjust(const f_array_length_t length, f_states_t *states) {
+#if !defined(_di_f_states_adjust_) || !defined(_di_f_states_decimate_by_)
+ f_status_t private_f_states_adjust(const f_array_length_t length, f_states_t *states) {
const f_status_t status = f_memory_adjust(states->size, length, sizeof(f_state_t), (void **) & states->array);
return status;
}
-#endif // !defined(_di_f_type_states_adjust_) || !defined(_di_f_type_states_decimate_by_)
+#endif // !defined(_di_f_states_adjust_) || !defined(_di_f_states_decimate_by_)
-#if !defined(_di_f_type_states_append_) || !defined(_di_f_type_statess_append_)
- extern f_status_t private_f_type_states_append(const f_states_t source, f_states_t *destination) {
+#if !defined(_di_f_states_append_) || !defined(_di_f_statess_append_)
+ extern f_status_t private_f_states_append(const f_states_t source, f_states_t *destination) {
f_status_t status = F_none;
if (destination->used + source.used > destination->size) {
- status = private_f_type_states_adjust(destination->used + source.used, destination);
+ status = private_f_states_adjust(destination->used + source.used, destination);
if (F_status_is_error(status)) return status;
}
return F_none;
}
-#endif // !defined(_di_f_type_states_append_) || !defined(_di_f_type_statess_append_)
+#endif // !defined(_di_f_states_append_) || !defined(_di_f_statess_append_)
-#if !defined(_di_f_type_states_resize_) || !defined(_di_f_type_states_append_) || !defined(_di_f_type_states_decimate_by_) || !defined(_di_f_type_statess_append_)
- f_status_t private_f_type_states_resize(const f_array_length_t length, f_states_t *states) {
+#if !defined(_di_f_states_resize_) || !defined(_di_f_states_append_) || !defined(_di_f_states_decimate_by_) || !defined(_di_f_statess_append_)
+ f_status_t private_f_states_resize(const f_array_length_t length, f_states_t *states) {
const f_status_t status = f_memory_resize(states->size, length, sizeof(f_state_t), (void **) & states->array);
return status;
}
-#endif // !defined(_di_f_type_states_resize_) || !defined(_di_f_type_states_append_) || !defined(_di_f_type_states_decimate_by_) || !defined(_di_f_type_statess_append_)
+#endif // !defined(_di_f_states_resize_) || !defined(_di_f_states_append_) || !defined(_di_f_states_decimate_by_) || !defined(_di_f_statess_append_)
-#if !defined(_di_f_type_statess_adjust_) || !defined(_di_f_type_statess_decimate_by_)
- f_status_t private_f_type_statess_adjust(const f_array_length_t length, f_statess_t *statess) {
+#if !defined(_di_f_statess_adjust_) || !defined(_di_f_statess_decimate_by_)
+ f_status_t private_f_statess_adjust(const f_array_length_t length, f_statess_t *statess) {
f_status_t status = F_none;
return status;
}
-#endif // !defined(_di_f_type_statess_adjust_) || !defined(_di_f_type_statess_decimate_by_)
+#endif // !defined(_di_f_statess_adjust_) || !defined(_di_f_statess_decimate_by_)
-#if !defined(_di_f_type_statess_decrease_by_) || !defined(_di_f_type_statess_increase_) || !defined(_di_f_type_statess_increase_by_) || !defined(_di_f_type_statess_resize_)
- f_status_t private_f_type_statess_resize(const f_array_length_t length, f_statess_t *statess) {
+#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_array_length_t length, f_statess_t *statess) {
f_status_t status = F_none;
return status;
}
-#endif // !defined(_di_f_type_statess_decrease_by_) || !defined(_di_f_type_statess_increase_) || !defined(_di_f_type_statess_increase_by_) || !defined(_di_f_type_statess_resize_)
+#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
} // extern "C"
*
* Errors (with error bit) from: f_memory_adjust().
*
- * @see f_type_states_adjust()
- * @see f_type_states_decimate_by()
+ * @see f_states_adjust()
+ * @see f_states_decimate_by()
*/
-#if !defined(_di_f_type_states_adjust_) || !defined(_di_f_type_states_decimate_by_)
- extern f_status_t private_f_type_states_adjust(const f_array_length_t length, f_states_t *states) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_type_states_adjust_) || !defined(_di_f_type_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_array_length_t length, f_states_t *states) F_attribute_visibility_internal_d;
+#endif // !defined(_di_f_states_adjust_) || !defined(_di_f_states_decimate_by_)
/**
* Private implementation for appending the state array.
*
* Errors (with error bit) from: f_memory_resize().
*
- * @see f_type_states_append()
- * @see f_type_statess_append()
+ * @see f_states_append()
+ * @see f_statess_append()
*/
-#if !defined(_di_f_type_states_append_) || !defined(_di_f_type_statess_append_)
- extern f_status_t private_f_type_states_append(const f_states_t source, f_states_t *destination) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_type_states_append_) || !defined(_di_f_type_statess_append_)
+#if !defined(_di_f_states_append_) || !defined(_di_f_statess_append_)
+ extern f_status_t private_f_states_append(const f_states_t source, f_states_t *destination) F_attribute_visibility_internal_d;
+#endif // !defined(_di_f_states_append_) || !defined(_di_f_statess_append_)
/**
* Private implementation for resizing the states array.
*
* Errors (with error bit) from: f_memory_resize().
*
- * @see f_type_states_resize()
- * @see f_type_states_append()
- * @see f_type_states_decimate_by()
- * @see f_type_statess_append()
+ * @see f_states_resize()
+ * @see f_states_append()
+ * @see f_states_decimate_by()
+ * @see f_statess_append()
*/
-#if !defined(_di_f_type_states_resize_) || !defined(_di_f_type_states_append_) || !defined(_di_f_type_states_decimate_by_) || !defined(_di_f_type_statess_append_)
- extern f_status_t private_f_type_states_resize(const f_array_length_t length, f_states_t *states) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_type_states_resize_) || !defined(_di_f_type_states_append_) || !defined(_di_f_type_states_decimate_by_) || !defined(_di_f_type_statess_append_)
+#if !defined(_di_f_states_resize_) || !defined(_di_f_states_append_) || !defined(_di_f_states_decimate_by_) || !defined(_di_f_statess_append_)
+ extern f_status_t private_f_states_resize(const f_array_length_t length, f_states_t *states) F_attribute_visibility_internal_d;
+#endif // !defined(_di_f_states_resize_) || !defined(_di_f_states_append_) || !defined(_di_f_states_decimate_by_) || !defined(_di_f_statess_append_)
/**
* Private implementation for resizing the statess array.
* Errors (with error bit) from: f_memory_adjust().
* Errors (with error bit) from: f_memory_destroy().
*
- * @see f_type_statess_adjust()
- * @see f_type_statess_decimate_by()
+ * @see f_statess_adjust()
+ * @see f_statess_decimate_by()
*/
-#if !defined(_di_f_type_statess_adjust_) || !defined(_di_f_type_statess_decimate_by_)
- extern f_status_t private_f_type_statess_adjust(const f_array_length_t length, f_statess_t *statess) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_type_statess_adjust_) || !defined(_di_f_type_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_array_length_t length, f_statess_t *statess) F_attribute_visibility_internal_d;
+#endif // !defined(_di_f_statess_adjust_) || !defined(_di_f_statess_decimate_by_)
/**
* Private implementation for resizing the statess array.
* Errors (with error bit) from: f_memory_delete().
* Errors (with error bit) from: f_memory_resize().
*
- * @see f_type_statess_decrease_by()
- * @see f_type_statess_increase()
- * @see f_type_statess_increase_by()
- * @see f_type_statess_resize()
+ * @see f_statess_decrease_by()
+ * @see f_statess_increase()
+ * @see f_statess_increase_by()
+ * @see f_statess_resize()
*/
-#if !defined(_di_f_type_statess_decrease_by_) || !defined(_di_f_type_statess_increase_) || !defined(_di_f_type_statess_increase_by_) || !defined(_di_f_type_statess_resize_)
- extern f_status_t private_f_type_statess_resize(const f_array_length_t length, f_statess_t *statess) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_type_statess_decrease_by_) || !defined(_di_f_type_statess_increase_) || !defined(_di_f_type_statess_increase_by_) || !defined(_di_f_type_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_array_length_t length, f_statess_t *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
} // extern "C"
extern "C" {
#endif
-#if !defined(_di_f_type_statuss_adjust_) || !defined(_di_f_type_statuss_decimate_by_)
- f_status_t private_f_type_statuss_adjust(const f_array_length_t length, f_statuss_t *statuss) {
+#if !defined(_di_f_statuss_adjust_) || !defined(_di_f_statuss_decimate_by_)
+ f_status_t private_f_statuss_adjust(const f_array_length_t length, f_statuss_t *statuss) {
const f_status_t status = f_memory_adjust(statuss->size, length, sizeof(f_status_t), (void **) & statuss->array);
return status;
}
-#endif // !defined(_di_f_type_statuss_adjust_) || !defined(_di_f_type_statuss_decimate_by_)
+#endif // !defined(_di_f_statuss_adjust_) || !defined(_di_f_statuss_decimate_by_)
-#if !defined(_di_f_type_statuss_append_) || !defined(_di_f_type_statusss_append_)
- extern f_status_t private_f_type_statuss_append(const f_statuss_t source, f_statuss_t *destination) {
+#if !defined(_di_f_statuss_append_) || !defined(_di_f_statusss_append_)
+ extern f_status_t private_f_statuss_append(const f_statuss_t source, f_statuss_t *destination) {
f_status_t status = F_none;
if (destination->used + source.used > destination->size) {
- status = private_f_type_statuss_adjust(destination->used + source.used, destination);
+ status = private_f_statuss_adjust(destination->used + source.used, destination);
if (F_status_is_error(status)) return status;
}
return F_none;
}
-#endif // !defined(_di_f_type_statuss_append_) || !defined(_di_f_type_statusss_append_)
+#endif // !defined(_di_f_statuss_append_) || !defined(_di_f_statusss_append_)
-#if !defined(_di_f_type_statuss_resize_) || !defined(_di_f_type_statuss_append_) || !defined(_di_f_type_statuss_decimate_by_) || !defined(_di_f_type_statusss_append_)
- f_status_t private_f_type_statuss_resize(const f_array_length_t length, f_statuss_t *statuss) {
+#if !defined(_di_f_statuss_resize_) || !defined(_di_f_statuss_append_) || !defined(_di_f_statuss_decimate_by_) || !defined(_di_f_statusss_append_)
+ f_status_t private_f_statuss_resize(const f_array_length_t length, f_statuss_t *statuss) {
const f_status_t status = f_memory_resize(statuss->size, length, sizeof(f_status_t), (void **) & statuss->array);
return status;
}
-#endif // !defined(_di_f_type_statuss_resize_) || !defined(_di_f_type_statuss_append_) || !defined(_di_f_type_statuss_decimate_by_) || !defined(_di_f_type_statusss_append_)
+#endif // !defined(_di_f_statuss_resize_) || !defined(_di_f_statuss_append_) || !defined(_di_f_statuss_decimate_by_) || !defined(_di_f_statusss_append_)
-#if !defined(_di_f_type_statusss_adjust_) || !defined(_di_f_type_statusss_decimate_by_)
- f_status_t private_f_type_statusss_adjust(const f_array_length_t length, f_statusss_t *statusss) {
+#if !defined(_di_f_statusss_adjust_) || !defined(_di_f_statusss_decimate_by_)
+ f_status_t private_f_statusss_adjust(const f_array_length_t length, f_statusss_t *statusss) {
f_status_t status = F_none;
return status;
}
-#endif // !defined(_di_f_type_statusss_adjust_) || !defined(_di_f_type_statusss_decimate_by_)
+#endif // !defined(_di_f_statusss_adjust_) || !defined(_di_f_statusss_decimate_by_)
-#if !defined(_di_f_type_statusss_decrease_by_) || !defined(_di_f_type_statusss_increase_) || !defined(_di_f_type_statusss_increase_by_) || !defined(_di_f_type_statusss_resize_)
- f_status_t private_f_type_statusss_resize(const f_array_length_t length, f_statusss_t *statusss) {
+#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_array_length_t length, f_statusss_t *statusss) {
f_status_t status = F_none;
return status;
}
-#endif // !defined(_di_f_type_statusss_decrease_by_) || !defined(_di_f_type_statusss_increase_) || !defined(_di_f_type_statusss_increase_by_) || !defined(_di_f_type_statusss_resize_)
+#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
} // extern "C"
*
* Errors (with error bit) from: f_memory_adjust().
*
- * @see f_type_statuss_adjust()
- * @see f_type_statuss_decimate_by()
+ * @see f_statuss_adjust()
+ * @see f_statuss_decimate_by()
*/
-#if !defined(_di_f_type_statuss_adjust_) || !defined(_di_f_type_statuss_decimate_by_)
- extern f_status_t private_f_type_statuss_adjust(const f_array_length_t length, f_statuss_t *statuss) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_type_statuss_adjust_) || !defined(_di_f_type_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_array_length_t length, f_statuss_t *statuss) F_attribute_visibility_internal_d;
+#endif // !defined(_di_f_statuss_adjust_) || !defined(_di_f_statuss_decimate_by_)
/**
* Private implementation for appending the status array.
*
* Errors (with error bit) from: f_memory_resize().
*
- * @see f_type_statuss_append()
- * @see f_type_statusss_append()
+ * @see f_statuss_append()
+ * @see f_statusss_append()
*/
-#if !defined(_di_f_type_statuss_append_) || !defined(_di_f_type_statusss_append_)
- extern f_status_t private_f_type_statuss_append(const f_statuss_t source, f_statuss_t *destination) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_type_statuss_append_) || !defined(_di_f_type_statusss_append_)
+#if !defined(_di_f_statuss_append_) || !defined(_di_f_statusss_append_)
+ extern f_status_t private_f_statuss_append(const f_statuss_t source, f_statuss_t *destination) F_attribute_visibility_internal_d;
+#endif // !defined(_di_f_statuss_append_) || !defined(_di_f_statusss_append_)
/**
* Private implementation for resizing the statuss array.
*
* Errors (with error bit) from: f_memory_resize().
*
- * @see f_type_statuss_resize()
- * @see f_type_statuss_append()
- * @see f_type_statuss_decimate_by()
- * @see f_type_statusss_append()
+ * @see f_statuss_resize()
+ * @see f_statuss_append()
+ * @see f_statuss_decimate_by()
+ * @see f_statusss_append()
*/
-#if !defined(_di_f_type_statuss_resize_) || !defined(_di_f_type_statuss_append_) || !defined(_di_f_type_statuss_decimate_by_) || !defined(_di_f_type_statusss_append_)
- extern f_status_t private_f_type_statuss_resize(const f_array_length_t length, f_statuss_t *statuss) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_type_statuss_resize_) || !defined(_di_f_type_statuss_append_) || !defined(_di_f_type_statuss_decimate_by_) || !defined(_di_f_type_statusss_append_)
+#if !defined(_di_f_statuss_resize_) || !defined(_di_f_statuss_append_) || !defined(_di_f_statuss_decimate_by_) || !defined(_di_f_statusss_append_)
+ extern f_status_t private_f_statuss_resize(const f_array_length_t length, f_statuss_t *statuss) F_attribute_visibility_internal_d;
+#endif // !defined(_di_f_statuss_resize_) || !defined(_di_f_statuss_append_) || !defined(_di_f_statuss_decimate_by_) || !defined(_di_f_statusss_append_)
/**
* Private implementation for resizing the statusss array.
* Errors (with error bit) from: f_memory_adjust().
* Errors (with error bit) from: f_memory_destroy().
*
- * @see f_type_statusss_adjust()
- * @see f_type_statusss_decimate_by()
+ * @see f_statusss_adjust()
+ * @see f_statusss_decimate_by()
*/
-#if !defined(_di_f_type_statusss_adjust_) || !defined(_di_f_type_statusss_decimate_by_)
- extern f_status_t private_f_type_statusss_adjust(const f_array_length_t length, f_statusss_t *statusss) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_type_statusss_adjust_) || !defined(_di_f_type_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_array_length_t length, f_statusss_t *statusss) F_attribute_visibility_internal_d;
+#endif // !defined(_di_f_statusss_adjust_) || !defined(_di_f_statusss_decimate_by_)
/**
* Private implementation for resizing the statusss array.
* Errors (with error bit) from: f_memory_delete().
* Errors (with error bit) from: f_memory_resize().
*
- * @see f_type_statusss_decrease_by()
- * @see f_type_statusss_increase()
- * @see f_type_statusss_increase_by()
- * @see f_type_statusss_resize()
+ * @see f_statusss_decrease_by()
+ * @see f_statusss_increase()
+ * @see f_statusss_increase_by()
+ * @see f_statusss_resize()
*/
-#if !defined(_di_f_type_statusss_decrease_by_) || !defined(_di_f_type_statusss_increase_) || !defined(_di_f_type_statusss_increase_by_) || !defined(_di_f_type_statusss_resize_)
- extern f_status_t private_f_type_statusss_resize(const f_array_length_t length, f_statusss_t *statusss) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_type_statusss_decrease_by_) || !defined(_di_f_type_statusss_increase_) || !defined(_di_f_type_statusss_increase_by_) || !defined(_di_f_type_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_array_length_t length, f_statusss_t *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
} // extern "C"
extern "C" {
#endif
-#ifndef _di_f_type_states_adjust_
- f_status_t f_type_states_adjust(const f_array_length_t length, f_states_t *states) {
+#ifndef _di_f_states_adjust_
+ f_status_t f_states_adjust(const f_array_length_t length, f_states_t *states) {
#ifndef _di_level_0_parameter_checking_
if (!states) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
- return private_f_type_states_adjust(length, states);
+ return private_f_states_adjust(length, states);
}
-#endif // _di_f_type_states_adjust_
+#endif // _di_f_states_adjust_
-#ifndef _di_f_type_states_append_
- f_status_t f_type_states_append(const f_states_t source, f_states_t *destination) {
+#ifndef _di_f_states_append_
+ f_status_t f_states_append(const f_states_t source, f_states_t *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_type_states_append(source, destination);
+ return private_f_states_append(source, destination);
}
-#endif // _di_f_type_states_append_
+#endif // _di_f_states_append_
-#ifndef _di_f_type_states_decimate_by_
- f_status_t f_type_states_decimate_by(const f_array_length_t amount, f_states_t *states) {
+#ifndef _di_f_states_decimate_by_
+ f_status_t f_states_decimate_by(const f_array_length_t amount, f_states_t *states) {
#ifndef _di_level_0_parameter_checking_
if (!amount) return F_status_set_error(F_parameter);
if (!states) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
if (states->size - amount > 0) {
- return private_f_type_states_adjust(states->size - amount, states);
+ return private_f_states_adjust(states->size - amount, states);
}
- return private_f_type_states_adjust(0, states);
+ return private_f_states_adjust(0, states);
}
-#endif // _di_f_type_states_decimate_by_
+#endif // _di_f_states_decimate_by_
-#ifndef _di_f_type_states_decrease_by_
- f_status_t f_type_states_decrease_by(const f_array_length_t amount, f_states_t *states) {
+#ifndef _di_f_states_decrease_by_
+ f_status_t f_states_decrease_by(const f_array_length_t amount, f_states_t *states) {
#ifndef _di_level_0_parameter_checking_
if (!amount) return F_status_set_error(F_parameter);
if (!states) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
if (states->size - amount > 0) {
- return private_f_type_states_resize(states->size - amount, states);
+ return private_f_states_resize(states->size - amount, states);
}
- return private_f_type_states_resize(0, states);
+ return private_f_states_resize(0, states);
}
-#endif // _di_f_type_states_decrease_by_
+#endif // _di_f_states_decrease_by_
-#ifndef _di_f_type_states_increase_
- f_status_t f_type_states_increase(const uint16_t step, f_states_t *states) {
+#ifndef _di_f_states_increase_
+ f_status_t f_states_increase(const uint16_t step, f_states_t *states) {
#ifndef _di_level_0_parameter_checking_
if (!step) return F_status_set_error(F_parameter);
if (!states) return F_status_set_error(F_parameter);
size = F_array_length_t_size_d;
}
- return private_f_type_states_resize(size, states);
+ return private_f_states_resize(size, states);
}
return F_data_not;
}
-#endif // _di_f_type_states_increase_
+#endif // _di_f_states_increase_
-#ifndef _di_f_type_states_increase_by_
- f_status_t f_type_states_increase_by(const f_array_length_t amount, f_states_t *states) {
+#ifndef _di_f_states_increase_by_
+ f_status_t f_states_increase_by(const f_array_length_t amount, f_states_t *states) {
#ifndef _di_level_0_parameter_checking_
if (!amount) return F_status_set_error(F_parameter);
if (!states) return F_status_set_error(F_parameter);
return F_status_set_error(F_array_too_large);
}
- return private_f_type_states_resize(states->used + amount, states);
+ return private_f_states_resize(states->used + amount, states);
}
return F_data_not;
}
-#endif // _di_f_type_states_increase_by_
+#endif // _di_f_states_increase_by_
-#ifndef _di_f_type_states_resize_
- f_status_t f_type_states_resize(const f_array_length_t length, f_states_t *states) {
+#ifndef _di_f_states_resize_
+ f_status_t f_states_resize(const f_array_length_t length, f_states_t *states) {
#ifndef _di_level_0_parameter_checking_
if (!states) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
- return private_f_type_states_resize(length, states);
+ return private_f_states_resize(length, states);
}
-#endif // _di_f_type_states_resize_
+#endif // _di_f_states_resize_
-#ifndef _di_f_type_statess_adjust_
- f_status_t f_type_statess_adjust(const f_array_length_t length, f_statess_t *statess) {
+#ifndef _di_f_statess_adjust_
+ f_status_t f_statess_adjust(const f_array_length_t length, f_statess_t *statess) {
#ifndef _di_level_0_parameter_checking_
if (!statess) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
- return private_f_type_statess_adjust(length, statess);
+ return private_f_statess_adjust(length, statess);
}
-#endif // _di_f_type_statess_adjust_
+#endif // _di_f_statess_adjust_
-#ifndef _di_f_type_statess_append_
- f_status_t f_type_statess_append(const f_statess_t source, f_statess_t *destination) {
+#ifndef _di_f_statess_append_
+ f_status_t f_statess_append(const f_statess_t source, f_statess_t *destination) {
#ifndef _di_level_0_parameter_checking_
if (!destination) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
f_status_t status = F_none;
if (destination->used + source.used > destination->size) {
- status = private_f_type_statess_resize(destination->used + source.used, destination);
+ status = private_f_statess_resize(destination->used + source.used, destination);
if (F_status_is_error(status)) return status;
}
for (f_array_length_t i = 0; i < source.used; ++i, ++destination->used) {
- status = private_f_type_states_append(source.array[i], &destination->array[destination->used]);
+ status = private_f_states_append(source.array[i], &destination->array[destination->used]);
if (F_status_is_error(status)) return status;
} // for
return F_none;
}
-#endif // _di_f_type_statess_append_
+#endif // _di_f_statess_append_
-#ifndef _di_f_type_statess_decimate_by_
- f_status_t f_type_statess_decimate_by(const f_array_length_t amount, f_statess_t *statess) {
+#ifndef _di_f_statess_decimate_by_
+ f_status_t f_statess_decimate_by(const f_array_length_t amount, f_statess_t *statess) {
#ifndef _di_level_0_parameter_checking_
if (!amount) return F_status_set_error(F_parameter);
if (!statess) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
if (statess->size - amount > 0) {
- return private_f_type_statess_adjust(statess->size - amount, statess);
+ return private_f_statess_adjust(statess->size - amount, statess);
}
- return private_f_type_statess_adjust(0, statess);
+ return private_f_statess_adjust(0, statess);
}
-#endif // _di_f_type_statess_decimate_by_
+#endif // _di_f_statess_decimate_by_
-#ifndef _di_f_type_statess_decrease_by_
- f_status_t f_type_statess_decrease_by(const f_array_length_t amount, f_statess_t *statess) {
+#ifndef _di_f_statess_decrease_by_
+ f_status_t f_statess_decrease_by(const f_array_length_t amount, f_statess_t *statess) {
#ifndef _di_level_0_parameter_checking_
if (!amount) return F_status_set_error(F_parameter);
if (!statess) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
if (statess->size - amount > 0) {
- return private_f_type_statess_resize(statess->size - amount, statess);
+ return private_f_statess_resize(statess->size - amount, statess);
}
- return private_f_type_statess_resize(0, statess);
+ return private_f_statess_resize(0, statess);
}
-#endif // _di_f_type_statess_decrease_by_
+#endif // _di_f_statess_decrease_by_
-#ifndef _di_f_type_statess_increase_
- f_status_t f_type_statess_increase(const uint16_t step, f_statess_t *statess) {
+#ifndef _di_f_statess_increase_
+ f_status_t f_statess_increase(const uint16_t step, f_statess_t *statess) {
#ifndef _di_level_0_parameter_checking_
if (!step) return F_status_set_error(F_parameter);
if (!statess) return F_status_set_error(F_parameter);
size = F_array_length_t_size_d;
}
- return private_f_type_statess_resize(size, statess);
+ return private_f_statess_resize(size, statess);
}
return F_data_not;
}
-#endif // _di_f_type_statess_increase_
+#endif // _di_f_statess_increase_
-#ifndef _di_f_type_statess_increase_by_
- f_status_t f_type_statess_increase_by(const f_array_length_t amount, f_statess_t *statess) {
+#ifndef _di_f_statess_increase_by_
+ f_status_t f_statess_increase_by(const f_array_length_t amount, f_statess_t *statess) {
#ifndef _di_level_0_parameter_checking_
if (!amount) return F_status_set_error(F_parameter);
if (!statess) return F_status_set_error(F_parameter);
return F_status_set_error(F_array_too_large);
}
- return private_f_type_statess_resize(statess->used + amount, statess);
+ return private_f_statess_resize(statess->used + amount, statess);
}
return F_data_not;
}
-#endif // _di_f_type_statess_increase_by_
+#endif // _di_f_statess_increase_by_
-#ifndef _di_f_type_statess_resize_
- f_status_t f_type_statess_resize(const f_array_length_t length, f_statess_t *statess) {
+#ifndef _di_f_statess_resize_
+ f_status_t f_statess_resize(const f_array_length_t length, f_statess_t *statess) {
#ifndef _di_level_0_parameter_checking_
if (!statess) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
- return private_f_type_statess_resize(length, statess);
+ return private_f_statess_resize(length, statess);
}
-#endif // _di_f_type_statess_resize_
+#endif // _di_f_statess_resize_
#ifdef __cplusplus
} // extern "C"
*
* Errors (with error bit) from: f_memory_adjust().
*/
-#ifndef _di_f_type_states_adjust_
- extern f_status_t f_type_states_adjust(const f_array_length_t length, f_states_t *states);
-#endif // _di_f_type_states_adjust_
+#ifndef _di_f_states_adjust_
+ extern f_status_t f_states_adjust(const f_array_length_t length, f_states_t *states);
+#endif // _di_f_states_adjust_
/**
* Append the source states onto the destination.
*
* Errors (with error bit) from: f_memory_resize().
*/
-#ifndef _di_f_type_states_append_
- extern f_status_t f_type_states_append(const f_states_t source, f_states_t *destination);
-#endif // _di_f_type_states_append_
+#ifndef _di_f_states_append_
+ extern f_status_t f_states_append(const f_states_t source, f_states_t *destination);
+#endif // _di_f_states_append_
/**
* Resize the string states array to a smaller size.
*
* Errors (with error bit) from: f_memory_adjust().
*/
-#ifndef _di_f_type_states_decimate_by_
- extern f_status_t f_type_states_decimate_by(const f_array_length_t amount, f_states_t *states);
-#endif // _di_f_type_states_decimate_by_
+#ifndef _di_f_states_decimate_by_
+ extern f_status_t f_states_decimate_by(const f_array_length_t amount, f_states_t *states);
+#endif // _di_f_states_decimate_by_
/**
* Resize the string states array to a smaller size.
*
* Errors (with error bit) from: f_memory_resize().
*/
-#ifndef _di_f_type_states_decrease_by_
- extern f_status_t f_type_states_decrease_by(const f_array_length_t amount, f_states_t *states);
-#endif // _di_f_type_states_decrease_by_
+#ifndef _di_f_states_decrease_by_
+ extern f_status_t f_states_decrease_by(const f_array_length_t amount, f_states_t *states);
+#endif // _di_f_states_decrease_by_
/**
* Increase the size of the string states array, but only if necesary.
*
* Errors (with error bit) from: f_memory_resize().
*/
-#ifndef _di_f_type_states_increase_
- extern f_status_t f_type_states_increase(const uint16_t step, f_states_t *states);
-#endif // _di_f_type_states_increase_
+#ifndef _di_f_states_increase_
+ extern f_status_t f_states_increase(const uint16_t step, f_states_t *states);
+#endif // _di_f_states_increase_
/**
* Resize the string states array to a larger size.
*
* Errors (with error bit) from: f_memory_resize().
*/
-#ifndef _di_f_type_states_increase_by_
- extern f_status_t f_type_states_increase_by(const f_array_length_t amount, f_states_t *states);
-#endif // _di_f_type_states_increase_by_
+#ifndef _di_f_states_increase_by_
+ extern f_status_t f_states_increase_by(const f_array_length_t amount, f_states_t *states);
+#endif // _di_f_states_increase_by_
/**
* Resize the string states array.
*
* Errors (with error bit) from: f_memory_resize().
*/
-#ifndef _di_f_type_states_resize_
- extern f_status_t f_type_states_resize(const f_array_length_t length, f_states_t *states);
-#endif // _di_f_type_states_resize_
+#ifndef _di_f_states_resize_
+ extern f_status_t f_states_resize(const f_array_length_t length, f_states_t *states);
+#endif // _di_f_states_resize_
/**
* Resize the string statess array.
* Errors (with error bit) from: f_memory_adjust().
* Errors (with error bit) from: f_memory_destroy().
*/
-#ifndef _di_f_type_statess_adjust_
- extern f_status_t f_type_statess_adjust(const f_array_length_t length, f_statess_t *statess);
-#endif // _di_f_type_statess_adjust_
+#ifndef _di_f_statess_adjust_
+ extern f_status_t f_statess_adjust(const f_array_length_t length, f_statess_t *statess);
+#endif // _di_f_statess_adjust_
/**
* Append the source statess onto the destination.
*
* Errors (with error bit) from: f_memory_resize().
*/
-#ifndef _di_f_type_statess_append_
- extern f_status_t f_type_statess_append(const f_statess_t source, f_statess_t *destination);
-#endif // _di_f_type_statess_append_
+#ifndef _di_f_statess_append_
+ extern f_status_t f_statess_append(const f_statess_t source, f_statess_t *destination);
+#endif // _di_f_statess_append_
/**
* Resize the string statess array.
* Errors (with error bit) from: f_memory_adjust().
* Errors (with error bit) from: f_memory_destroy().
*/
-#ifndef _di_f_type_statess_adjust_
- extern f_status_t f_type_statess_adjust(const f_array_length_t length, f_statess_t *statess);
-#endif // _di_f_type_statess_adjust_
+#ifndef _di_f_statess_adjust_
+ extern f_status_t f_statess_adjust(const f_array_length_t length, f_statess_t *statess);
+#endif // _di_f_statess_adjust_
/**
* Resize the string statess array to a smaller size.
* Errors (with error bit) from: f_memory_adjust().
* Errors (with error bit) from: f_memory_destroy().
*/
-#ifndef _di_f_type_statess_decimate_by_
- extern f_status_t f_type_statess_decimate_by(const f_array_length_t amount, f_statess_t *statess);
-#endif // _di_f_type_statess_decimate_by_
+#ifndef _di_f_statess_decimate_by_
+ extern f_status_t f_statess_decimate_by(const f_array_length_t amount, f_statess_t *statess);
+#endif // _di_f_statess_decimate_by_
/**
* Resize the string statess array to a smaller size.
* Errors (with error bit) from: f_memory_delete().
* Errors (with error bit) from: f_memory_resize().
*/
-#ifndef _di_f_type_statess_decrease_by_
- extern f_status_t f_type_statess_decrease_by(const f_array_length_t amount, f_statess_t *statess);
-#endif // _di_f_type_statess_decrease_by_
+#ifndef _di_f_statess_decrease_by_
+ extern f_status_t f_statess_decrease_by(const f_array_length_t amount, f_statess_t *statess);
+#endif // _di_f_statess_decrease_by_
/**
* Increase the size of the string statess array, but only if necessary.
*
* Errors (with error bit) from: f_memory_resize().
*/
-#ifndef _di_f_type_statess_increase_
- extern f_status_t f_type_statess_increase(const uint16_t step, f_statess_t *statess);
-#endif // _di_f_type_statess_increase_
+#ifndef _di_f_statess_increase_
+ extern f_status_t f_statess_increase(const uint16_t step, f_statess_t *statess);
+#endif // _di_f_statess_increase_
/**
* Resize the string statess array to a larger size.
*
* Errors (with error bit) from: f_memory_resize().
*/
-#ifndef _di_f_type_statess_increase_by_
- extern f_status_t f_type_statess_increase_by(const f_array_length_t amount, f_statess_t *statess);
-#endif // _di_f_type_statess_increase_by_
+#ifndef _di_f_statess_increase_by_
+ extern f_status_t f_statess_increase_by(const f_array_length_t amount, f_statess_t *statess);
+#endif // _di_f_statess_increase_by_
/**
* Resize the string statess array.
* Errors (with error bit) from: f_memory_delete().
* Errors (with error bit) from: f_memory_resize().
*/
-#ifndef _di_f_type_statess_resize_
- extern f_status_t f_type_statess_resize(const f_array_length_t length, f_statess_t *statess);
-#endif // _di_f_type_statess_resize_
+#ifndef _di_f_statess_resize_
+ extern f_status_t f_statess_resize(const f_array_length_t length, f_statess_t *statess);
+#endif // _di_f_statess_resize_
#ifdef __cplusplus
} // extern "C"
extern "C" {
#endif
-#ifndef _di_f_type_statuss_adjust_
- f_status_t f_type_statuss_adjust(const f_array_length_t length, f_statuss_t *statuss) {
+#ifndef _di_f_statuss_adjust_
+ f_status_t f_statuss_adjust(const f_array_length_t length, f_statuss_t *statuss) {
#ifndef _di_level_0_parameter_checking_
if (!statuss) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
- return private_f_type_statuss_adjust(length, statuss);
+ return private_f_statuss_adjust(length, statuss);
}
-#endif // _di_f_type_statuss_adjust_
+#endif // _di_f_statuss_adjust_
-#ifndef _di_f_type_statuss_append_
- f_status_t f_type_statuss_append(const f_statuss_t source, f_statuss_t *destination) {
+#ifndef _di_f_statuss_append_
+ f_status_t f_statuss_append(const f_statuss_t source, f_statuss_t *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_type_statuss_append(source, destination);
+ return private_f_statuss_append(source, destination);
}
-#endif // _di_f_type_statuss_append_
+#endif // _di_f_statuss_append_
-#ifndef _di_f_type_statuss_decimate_by_
- f_status_t f_type_statuss_decimate_by(const f_array_length_t amount, f_statuss_t *statuss) {
+#ifndef _di_f_statuss_decimate_by_
+ f_status_t f_statuss_decimate_by(const f_array_length_t amount, f_statuss_t *statuss) {
#ifndef _di_level_0_parameter_checking_
if (!amount) return F_status_set_error(F_parameter);
if (!statuss) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
if (statuss->size - amount > 0) {
- return private_f_type_statuss_adjust(statuss->size - amount, statuss);
+ return private_f_statuss_adjust(statuss->size - amount, statuss);
}
- return private_f_type_statuss_adjust(0, statuss);
+ return private_f_statuss_adjust(0, statuss);
}
-#endif // _di_f_type_statuss_decimate_by_
+#endif // _di_f_statuss_decimate_by_
-#ifndef _di_f_type_statuss_decrease_by_
- f_status_t f_type_statuss_decrease_by(const f_array_length_t amount, f_statuss_t *statuss) {
+#ifndef _di_f_statuss_decrease_by_
+ f_status_t f_statuss_decrease_by(const f_array_length_t amount, f_statuss_t *statuss) {
#ifndef _di_level_0_parameter_checking_
if (!amount) return F_status_set_error(F_parameter);
if (!statuss) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
if (statuss->size - amount > 0) {
- return private_f_type_statuss_resize(statuss->size - amount, statuss);
+ return private_f_statuss_resize(statuss->size - amount, statuss);
}
- return private_f_type_statuss_resize(0, statuss);
+ return private_f_statuss_resize(0, statuss);
}
-#endif // _di_f_type_statuss_decrease_by_
+#endif // _di_f_statuss_decrease_by_
-#ifndef _di_f_type_statuss_increase_
- f_status_t f_type_statuss_increase(const uint16_t step, f_statuss_t *statuss) {
+#ifndef _di_f_statuss_increase_
+ f_status_t f_statuss_increase(const uint16_t step, f_statuss_t *statuss) {
#ifndef _di_level_0_parameter_checking_
if (!step) return F_status_set_error(F_parameter);
if (!statuss) return F_status_set_error(F_parameter);
size = F_array_length_t_size_d;
}
- return private_f_type_statuss_resize(size, statuss);
+ return private_f_statuss_resize(size, statuss);
}
return F_data_not;
}
-#endif // _di_f_type_statuss_increase_
+#endif // _di_f_statuss_increase_
-#ifndef _di_f_type_statuss_increase_by_
- f_status_t f_type_statuss_increase_by(const f_array_length_t amount, f_statuss_t *statuss) {
+#ifndef _di_f_statuss_increase_by_
+ f_status_t f_statuss_increase_by(const f_array_length_t amount, f_statuss_t *statuss) {
#ifndef _di_level_0_parameter_checking_
if (!amount) return F_status_set_error(F_parameter);
if (!statuss) return F_status_set_error(F_parameter);
return F_status_set_error(F_array_too_large);
}
- return private_f_type_statuss_resize(statuss->used + amount, statuss);
+ return private_f_statuss_resize(statuss->used + amount, statuss);
}
return F_data_not;
}
-#endif // _di_f_type_statuss_increase_by_
+#endif // _di_f_statuss_increase_by_
-#ifndef _di_f_type_statuss_resize_
- f_status_t f_type_statuss_resize(const f_array_length_t length, f_statuss_t *statuss) {
+#ifndef _di_f_statuss_resize_
+ f_status_t f_statuss_resize(const f_array_length_t length, f_statuss_t *statuss) {
#ifndef _di_level_0_parameter_checking_
if (!statuss) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
- return private_f_type_statuss_resize(length, statuss);
+ return private_f_statuss_resize(length, statuss);
}
-#endif // _di_f_type_statuss_resize_
+#endif // _di_f_statuss_resize_
-#ifndef _di_f_type_statusss_adjust_
- f_status_t f_type_statusss_adjust(const f_array_length_t length, f_statusss_t *statusss) {
+#ifndef _di_f_statusss_adjust_
+ f_status_t f_statusss_adjust(const f_array_length_t length, f_statusss_t *statusss) {
#ifndef _di_level_0_parameter_checking_
if (!statusss) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
- return private_f_type_statusss_adjust(length, statusss);
+ return private_f_statusss_adjust(length, statusss);
}
-#endif // _di_f_type_statusss_adjust_
+#endif // _di_f_statusss_adjust_
-#ifndef _di_f_type_statusss_append_
- f_status_t f_type_statusss_append(const f_statusss_t source, f_statusss_t *destination) {
+#ifndef _di_f_statusss_append_
+ f_status_t f_statusss_append(const f_statusss_t source, f_statusss_t *destination) {
#ifndef _di_level_0_parameter_checking_
if (!destination) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
f_status_t status = F_none;
if (destination->used + source.used > destination->size) {
- status = private_f_type_statusss_resize(destination->used + source.used, destination);
+ status = private_f_statusss_resize(destination->used + source.used, destination);
if (F_status_is_error(status)) return status;
}
for (f_array_length_t i = 0; i < source.used; ++i, ++destination->used) {
- status = private_f_type_statuss_append(source.array[i], &destination->array[destination->used]);
+ status = private_f_statuss_append(source.array[i], &destination->array[destination->used]);
if (F_status_is_error(status)) return status;
} // for
return F_none;
}
-#endif // _di_f_type_statusss_append_
+#endif // _di_f_statusss_append_
-#ifndef _di_f_type_statusss_decimate_by_
- f_status_t f_type_statusss_decimate_by(const f_array_length_t amount, f_statusss_t *statusss) {
+#ifndef _di_f_statusss_decimate_by_
+ f_status_t f_statusss_decimate_by(const f_array_length_t amount, f_statusss_t *statusss) {
#ifndef _di_level_0_parameter_checking_
if (!amount) return F_status_set_error(F_parameter);
if (!statusss) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
if (statusss->size - amount > 0) {
- return private_f_type_statusss_adjust(statusss->size - amount, statusss);
+ return private_f_statusss_adjust(statusss->size - amount, statusss);
}
- return private_f_type_statusss_adjust(0, statusss);
+ return private_f_statusss_adjust(0, statusss);
}
-#endif // _di_f_type_statusss_decimate_by_
+#endif // _di_f_statusss_decimate_by_
-#ifndef _di_f_type_statusss_decrease_by_
- f_status_t f_type_statusss_decrease_by(const f_array_length_t amount, f_statusss_t *statusss) {
+#ifndef _di_f_statusss_decrease_by_
+ f_status_t f_statusss_decrease_by(const f_array_length_t amount, f_statusss_t *statusss) {
#ifndef _di_level_0_parameter_checking_
if (!amount) return F_status_set_error(F_parameter);
if (!statusss) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
if (statusss->size - amount > 0) {
- return private_f_type_statusss_resize(statusss->size - amount, statusss);
+ return private_f_statusss_resize(statusss->size - amount, statusss);
}
- return private_f_type_statusss_resize(0, statusss);
+ return private_f_statusss_resize(0, statusss);
}
-#endif // _di_f_type_statusss_decrease_by_
+#endif // _di_f_statusss_decrease_by_
-#ifndef _di_f_type_statusss_increase_
- f_status_t f_type_statusss_increase(const uint16_t step, f_statusss_t *statusss) {
+#ifndef _di_f_statusss_increase_
+ f_status_t f_statusss_increase(const uint16_t step, f_statusss_t *statusss) {
#ifndef _di_level_0_parameter_checking_
if (!step) return F_status_set_error(F_parameter);
if (!statusss) return F_status_set_error(F_parameter);
size = F_array_length_t_size_d;
}
- return private_f_type_statusss_resize(size, statusss);
+ return private_f_statusss_resize(size, statusss);
}
return F_data_not;
}
-#endif // _di_f_type_statusss_increase_
+#endif // _di_f_statusss_increase_
-#ifndef _di_f_type_statusss_increase_by_
- f_status_t f_type_statusss_increase_by(const f_array_length_t amount, f_statusss_t *statusss) {
+#ifndef _di_f_statusss_increase_by_
+ f_status_t f_statusss_increase_by(const f_array_length_t amount, f_statusss_t *statusss) {
#ifndef _di_level_0_parameter_checking_
if (!amount) return F_status_set_error(F_parameter);
if (!statusss) return F_status_set_error(F_parameter);
return F_status_set_error(F_array_too_large);
}
- return private_f_type_statusss_resize(statusss->used + amount, statusss);
+ return private_f_statusss_resize(statusss->used + amount, statusss);
}
return F_data_not;
}
-#endif // _di_f_type_statusss_increase_by_
+#endif // _di_f_statusss_increase_by_
-#ifndef _di_f_type_statusss_resize_
- f_status_t f_type_statusss_resize(const f_array_length_t length, f_statusss_t *statusss) {
+#ifndef _di_f_statusss_resize_
+ f_status_t f_statusss_resize(const f_array_length_t length, f_statusss_t *statusss) {
#ifndef _di_level_0_parameter_checking_
if (!statusss) return F_status_set_error(F_parameter);
#endif // _di_level_0_parameter_checking_
- return private_f_type_statusss_resize(length, statusss);
+ return private_f_statusss_resize(length, statusss);
}
-#endif // _di_f_type_statusss_resize_
+#endif // _di_f_statusss_resize_
#ifdef __cplusplus
} // extern "C"
*
* Errors (with error bit) from: f_memory_adjust().
*/
-#ifndef _di_f_type_statuss_adjust_
- extern f_status_t f_type_statuss_adjust(const f_array_length_t length, f_statuss_t *statuss);
-#endif // _di_f_type_statuss_adjust_
+#ifndef _di_f_statuss_adjust_
+ extern f_status_t f_statuss_adjust(const f_array_length_t length, f_statuss_t *statuss);
+#endif // _di_f_statuss_adjust_
/**
* Append the source statuss onto the destination.
*
* Errors (with error bit) from: f_memory_resize().
*/
-#ifndef _di_f_type_statuss_append_
- extern f_status_t f_type_statuss_append(const f_statuss_t source, f_statuss_t *destination);
-#endif // _di_f_type_statuss_append_
+#ifndef _di_f_statuss_append_
+ extern f_status_t f_statuss_append(const f_statuss_t source, f_statuss_t *destination);
+#endif // _di_f_statuss_append_
/**
* Resize the string statuss array to a smaller size.
*
* Errors (with error bit) from: f_memory_adjust().
*/
-#ifndef _di_f_type_statuss_decimate_by_
- extern f_status_t f_type_statuss_decimate_by(const f_array_length_t amount, f_statuss_t *statuss);
-#endif // _di_f_type_statuss_decimate_by_
+#ifndef _di_f_statuss_decimate_by_
+ extern f_status_t f_statuss_decimate_by(const f_array_length_t amount, f_statuss_t *statuss);
+#endif // _di_f_statuss_decimate_by_
/**
* Resize the string statuss array to a smaller size.
*
* Errors (with error bit) from: f_memory_resize().
*/
-#ifndef _di_f_type_statuss_decrease_by_
- extern f_status_t f_type_statuss_decrease_by(const f_array_length_t amount, f_statuss_t *statuss);
-#endif // _di_f_type_statuss_decrease_by_
+#ifndef _di_f_statuss_decrease_by_
+ extern f_status_t f_statuss_decrease_by(const f_array_length_t amount, f_statuss_t *statuss);
+#endif // _di_f_statuss_decrease_by_
/**
* Increase the size of the string statuss array, but only if necesary.
*
* Errors (with error bit) from: f_memory_resize().
*/
-#ifndef _di_f_type_statuss_increase_
- extern f_status_t f_type_statuss_increase(const uint16_t step, f_statuss_t *statuss);
-#endif // _di_f_type_statuss_increase_
+#ifndef _di_f_statuss_increase_
+ extern f_status_t f_statuss_increase(const uint16_t step, f_statuss_t *statuss);
+#endif // _di_f_statuss_increase_
/**
* Resize the string statuss array to a larger size.
*
* Errors (with error bit) from: f_memory_resize().
*/
-#ifndef _di_f_type_statuss_increase_by_
- extern f_status_t f_type_statuss_increase_by(const f_array_length_t amount, f_statuss_t *statuss);
-#endif // _di_f_type_statuss_increase_by_
+#ifndef _di_f_statuss_increase_by_
+ extern f_status_t f_statuss_increase_by(const f_array_length_t amount, f_statuss_t *statuss);
+#endif // _di_f_statuss_increase_by_
/**
* Resize the string statuss array.
*
* Errors (with error bit) from: f_memory_resize().
*/
-#ifndef _di_f_type_statuss_resize_
- extern f_status_t f_type_statuss_resize(const f_array_length_t length, f_statuss_t *statuss);
-#endif // _di_f_type_statuss_resize_
+#ifndef _di_f_statuss_resize_
+ extern f_status_t f_statuss_resize(const f_array_length_t length, f_statuss_t *statuss);
+#endif // _di_f_statuss_resize_
/**
* Resize the string statusss array.
* Errors (with error bit) from: f_memory_adjust().
* Errors (with error bit) from: f_memory_destroy().
*/
-#ifndef _di_f_type_statusss_adjust_
- extern f_status_t f_type_statusss_adjust(const f_array_length_t length, f_statusss_t *statusss);
-#endif // _di_f_type_statusss_adjust_
+#ifndef _di_f_statusss_adjust_
+ extern f_status_t f_statusss_adjust(const f_array_length_t length, f_statusss_t *statusss);
+#endif // _di_f_statusss_adjust_
/**
* Append the source statusss onto the destination.
*
* Errors (with error bit) from: f_memory_resize().
*/
-#ifndef _di_f_type_statusss_append_
- extern f_status_t f_type_statusss_append(const f_statusss_t source, f_statusss_t *destination);
-#endif // _di_f_type_statusss_append_
+#ifndef _di_f_statusss_append_
+ extern f_status_t f_statusss_append(const f_statusss_t source, f_statusss_t *destination);
+#endif // _di_f_statusss_append_
/**
* Resize the string statusss array.
* Errors (with error bit) from: f_memory_adjust().
* Errors (with error bit) from: f_memory_destroy().
*/
-#ifndef _di_f_type_statusss_adjust_
- extern f_status_t f_type_statusss_adjust(const f_array_length_t length, f_statusss_t *statusss);
-#endif // _di_f_type_statusss_adjust_
+#ifndef _di_f_statusss_adjust_
+ extern f_status_t f_statusss_adjust(const f_array_length_t length, f_statusss_t *statusss);
+#endif // _di_f_statusss_adjust_
/**
* Resize the string statusss array to a smaller size.
* Errors (with error bit) from: f_memory_adjust().
* Errors (with error bit) from: f_memory_destroy().
*/
-#ifndef _di_f_type_statusss_decimate_by_
- extern f_status_t f_type_statusss_decimate_by(const f_array_length_t amount, f_statusss_t *statusss);
-#endif // _di_f_type_statusss_decimate_by_
+#ifndef _di_f_statusss_decimate_by_
+ extern f_status_t f_statusss_decimate_by(const f_array_length_t amount, f_statusss_t *statusss);
+#endif // _di_f_statusss_decimate_by_
/**
* Resize the string statusss array to a smaller size.
* Errors (with error bit) from: f_memory_delete().
* Errors (with error bit) from: f_memory_resize().
*/
-#ifndef _di_f_type_statusss_decrease_by_
- extern f_status_t f_type_statusss_decrease_by(const f_array_length_t amount, f_statusss_t *statusss);
-#endif // _di_f_type_statusss_decrease_by_
+#ifndef _di_f_statusss_decrease_by_
+ extern f_status_t f_statusss_decrease_by(const f_array_length_t amount, f_statusss_t *statusss);
+#endif // _di_f_statusss_decrease_by_
/**
* Increase the size of the string statusss array, but only if necessary.
*
* Errors (with error bit) from: f_memory_resize().
*/
-#ifndef _di_f_type_statusss_increase_
- extern f_status_t f_type_statusss_increase(const uint16_t step, f_statusss_t *statusss);
-#endif // _di_f_type_statusss_increase_
+#ifndef _di_f_statusss_increase_
+ extern f_status_t f_statusss_increase(const uint16_t step, f_statusss_t *statusss);
+#endif // _di_f_statusss_increase_
/**
* Resize the string statusss array to a larger size.
*
* Errors (with error bit) from: f_memory_resize().
*/
-#ifndef _di_f_type_statusss_increase_by_
- extern f_status_t f_type_statusss_increase_by(const f_array_length_t amount, f_statusss_t *statusss);
-#endif // _di_f_type_statusss_increase_by_
+#ifndef _di_f_statusss_increase_by_
+ extern f_status_t f_statusss_increase_by(const f_array_length_t amount, f_statusss_t *statusss);
+#endif // _di_f_statusss_increase_by_
/**
* Resize the string statusss array.
* Errors (with error bit) from: f_memory_delete().
* Errors (with error bit) from: f_memory_resize().
*/
-#ifndef _di_f_type_statusss_resize_
- extern f_status_t f_type_statusss_resize(const f_array_length_t length, f_statusss_t *statusss);
-#endif // _di_f_type_statusss_resize_
+#ifndef _di_f_statusss_resize_
+ extern f_status_t f_statusss_resize(const f_array_length_t length, f_statusss_t *statusss);
+#endif // _di_f_statusss_resize_
#ifdef __cplusplus
} // extern "C"
f_array_lengths_t data = f_array_lengths_t_initialize;
{
- const f_status_t status = f_type_array_lengths_adjust(length, &data);
+ const f_status_t status = f_array_lengths_adjust(length, &data);
assert_int_equal(status, F_none);
assert_int_equal(data.used, 0);
f_array_lengths_t data = f_array_lengths_t_initialize;
{
- const f_status_t status = f_type_array_lengths_adjust(length, 0);
+ const f_status_t status = f_array_lengths_adjust(length, 0);
assert_int_equal(status, F_status_set_error(F_parameter));
assert_int_equal(data.used, 0);
f_array_lengths_t destination = f_array_lengths_t_initialize;
{
- const f_status_t status = f_type_array_lengths_resize(length, &source);
+ const f_status_t status = f_array_lengths_resize(length, &source);
assert_int_equal(status, F_none);
assert_int_equal(source.used, 0);
} // for
{
- const f_status_t status = f_type_array_lengths_append(source, &destination);
+ const f_status_t status = f_array_lengths_append(source, &destination);
assert_int_equal(status, F_none);
assert_int_equal(destination.used, source.used);
f_array_lengths_t destination = f_array_lengths_t_initialize;
{
- const f_status_t status = f_type_array_lengths_resize(length, &source);
+ const f_status_t status = f_array_lengths_resize(length, &source);
assert_int_equal(status, F_none);
assert_int_equal(source.used, 0);
}
{
- const f_status_t status = f_type_array_lengths_append(source, &destination);
+ const f_status_t status = f_array_lengths_append(source, &destination);
assert_int_equal(status, F_data_not);
assert_int_equal(destination.used, 0);
f_array_lengths_t data = f_array_lengths_t_initialize;
{
- const f_status_t status = f_type_array_lengths_append(data, 0);
+ const f_status_t status = f_array_lengths_append(data, 0);
assert_int_equal(status, F_status_set_error(F_parameter));
assert_int_equal(data.used, 0);
f_array_lengths_t data = f_array_lengths_t_initialize;
{
- const f_status_t status = f_type_array_lengths_resize(length, &data);
+ const f_status_t status = f_array_lengths_resize(length, &data);
assert_int_equal(status, F_none);
assert_int_equal(data.used, 0);
}
{
- const f_status_t status = f_type_array_lengths_decimate_by(length, &data);
+ const f_status_t status = f_array_lengths_decimate_by(length, &data);
assert_int_equal(status, F_none);
assert_int_equal(data.used, 0);
f_array_lengths_t data = f_array_lengths_t_initialize;
{
- const f_status_t status = f_type_array_lengths_decimate_by(length, 0);
+ const f_status_t status = f_array_lengths_decimate_by(length, 0);
assert_int_equal(status, F_status_set_error(F_parameter));
assert_int_equal(data.used, 0);
f_array_lengths_t data = f_array_lengths_t_initialize;
{
- const f_status_t status = f_type_array_lengths_resize(length, &data);
+ const f_status_t status = f_array_lengths_resize(length, &data);
assert_int_equal(status, F_none);
assert_int_equal(data.used, 0);
}
{
- const f_status_t status = f_type_array_lengths_decrease_by(length, &data);
+ const f_status_t status = f_array_lengths_decrease_by(length, &data);
assert_int_equal(status, F_none);
assert_int_equal(data.used, 0);
f_array_lengths_t data = f_array_lengths_t_initialize;
{
- const f_status_t status = f_type_array_lengths_decrease_by(length, 0);
+ const f_status_t status = f_array_lengths_decrease_by(length, 0);
assert_int_equal(status, F_status_set_error(F_parameter));
assert_int_equal(data.used, 0);
f_array_lengths_t data = f_array_lengths_t_initialize;
{
- const f_status_t status = f_type_array_lengths_resize(length, &data);
+ const f_status_t status = f_array_lengths_resize(length, &data);
assert_int_equal(status, F_none);
assert_int_equal(data.used, 0);
{
data.used = length;
- const f_status_t status = f_type_array_lengths_increase(length, &data);
+ const f_status_t status = f_array_lengths_increase(length, &data);
assert_int_equal(status, F_none);
assert_int_equal(data.used, length);
f_array_lengths_t data = f_array_lengths_t_initialize;
{
- const f_status_t status = f_type_array_lengths_resize(length, &data);
+ const f_status_t status = f_array_lengths_resize(length, &data);
assert_int_equal(status, F_none);
assert_int_equal(data.used, 0);
}
{
- const f_status_t status = f_type_array_lengths_increase(length, &data);
+ const f_status_t status = f_array_lengths_increase(length, &data);
assert_int_equal(status, F_data_not);
assert_int_equal(data.used, 0);
f_array_lengths_t data = f_array_lengths_t_initialize;
{
- const f_status_t status = f_type_array_lengths_increase(length, 0);
+ const f_status_t status = f_array_lengths_increase(length, 0);
assert_int_equal(status, F_status_set_error(F_parameter));
assert_int_equal(data.used, 0);
f_array_lengths_t data = f_array_lengths_t_initialize;
{
- const f_status_t status = f_type_array_lengths_resize(length, &data);
+ const f_status_t status = f_array_lengths_resize(length, &data);
assert_int_equal(status, F_none);
assert_int_equal(data.used, 0);
{
data.used = length;
- const f_status_t status = f_type_array_lengths_increase_by(length, &data);
+ const f_status_t status = f_array_lengths_increase_by(length, &data);
assert_int_equal(status, F_none);
assert_int_equal(data.used, length);
f_array_lengths_t data = f_array_lengths_t_initialize;
{
- const f_status_t status = f_type_array_lengths_increase_by(length, 0);
+ const f_status_t status = f_array_lengths_increase_by(length, 0);
assert_int_equal(status, F_status_set_error(F_parameter));
assert_int_equal(data.used, 0);
f_array_lengths_t data = f_array_lengths_t_initialize;
{
- const f_status_t status = f_type_array_lengths_resize(length, &data);
+ const f_status_t status = f_array_lengths_resize(length, &data);
assert_int_equal(status, F_none);
assert_int_equal(data.used, 0);
f_array_lengths_t data = f_array_lengths_t_initialize;
{
- const f_status_t status = f_type_array_lengths_resize(length, 0);
+ const f_status_t status = f_array_lengths_resize(length, 0);
assert_int_equal(status, F_status_set_error(F_parameter));
assert_int_equal(data.used, 0);
f_array_lengthss_t data = f_array_lengthss_t_initialize;
{
- const f_status_t status = f_type_array_lengthss_adjust(length, &data);
+ const f_status_t status = f_array_lengthss_adjust(length, &data);
assert_int_equal(status, F_none);
assert_int_equal(data.used, 0);
f_array_lengthss_t data = f_array_lengthss_t_initialize;
{
- const f_status_t status = f_type_array_lengthss_adjust(length, 0);
+ const f_status_t status = f_array_lengthss_adjust(length, 0);
assert_int_equal(status, F_status_set_error(F_parameter));
assert_int_equal(data.used, 0);
f_array_lengthss_t destination = f_array_lengths_t_initialize;
{
- const f_status_t status = f_type_array_lengthss_resize(length, &source);
+ const f_status_t status = f_array_lengthss_resize(length, &source);
assert_int_equal(status, F_none);
assert_int_equal(source.used, 0);
{
for (; source.used < length; ++source.used) {
- const f_status_t status = f_type_array_lengths_resize(length_inner, &source.array[source.used]);
+ const f_status_t status = f_array_lengths_resize(length_inner, &source.array[source.used]);
assert_int_equal(status, F_none);
}
{
- const f_status_t status = f_type_array_lengthss_append(source, &destination);
+ const f_status_t status = f_array_lengthss_append(source, &destination);
assert_int_equal(status, F_none);
assert_int_equal(destination.used, source.used);
f_array_lengthss_t destination = f_array_lengths_t_initialize;
{
- const f_status_t status = f_type_array_lengthss_resize(length, &source);
+ const f_status_t status = f_array_lengthss_resize(length, &source);
assert_int_equal(status, F_none);
assert_int_equal(source.used, 0);
}
{
- const f_status_t status = f_type_array_lengthss_append(source, &destination);
+ const f_status_t status = f_array_lengthss_append(source, &destination);
assert_int_equal(status, F_data_not);
assert_int_equal(destination.used, 0);
f_array_lengthss_t data = f_array_lengths_t_initialize;
{
- const f_status_t status = f_type_array_lengthss_append(data, 0);
+ const f_status_t status = f_array_lengthss_append(data, 0);
assert_int_equal(status, F_status_set_error(F_parameter));
assert_int_equal(data.used, 0);
f_array_lengthss_t data = f_array_lengths_t_initialize;
{
- const f_status_t status = f_type_array_lengthss_resize(length, &data);
+ const f_status_t status = f_array_lengthss_resize(length, &data);
assert_int_equal(status, F_none);
assert_int_equal(data.used, 0);
}
{
- const f_status_t status = f_type_array_lengthss_decimate_by(length, &data);
+ const f_status_t status = f_array_lengthss_decimate_by(length, &data);
assert_int_equal(status, F_none);
assert_int_equal(data.used, 0);
f_array_lengthss_t data = f_array_lengths_t_initialize;
{
- const f_status_t status = f_type_array_lengthss_decimate_by(length, 0);
+ const f_status_t status = f_array_lengthss_decimate_by(length, 0);
assert_int_equal(status, F_status_set_error(F_parameter));
assert_int_equal(data.used, 0);
f_array_lengthss_t data = f_array_lengths_t_initialize;
{
- const f_status_t status = f_type_array_lengthss_resize(length, &data);
+ const f_status_t status = f_array_lengthss_resize(length, &data);
assert_int_equal(status, F_none);
assert_int_equal(data.used, 0);
}
{
- const f_status_t status = f_type_array_lengthss_decrease_by(length, &data);
+ const f_status_t status = f_array_lengthss_decrease_by(length, &data);
assert_int_equal(status, F_none);
assert_int_equal(data.used, 0);
f_array_lengthss_t data = f_array_lengths_t_initialize;
{
- const f_status_t status = f_type_array_lengthss_decrease_by(length, 0);
+ const f_status_t status = f_array_lengthss_decrease_by(length, 0);
assert_int_equal(status, F_status_set_error(F_parameter));
assert_int_equal(data.used, 0);
f_array_lengthss_t data = f_array_lengths_t_initialize;
{
- const f_status_t status = f_type_array_lengthss_resize(length, &data);
+ const f_status_t status = f_array_lengthss_resize(length, &data);
assert_int_equal(status, F_none);
assert_int_equal(data.used, 0);
{
data.used = length;
- const f_status_t status = f_type_array_lengthss_increase(length, &data);
+ const f_status_t status = f_array_lengthss_increase(length, &data);
assert_int_equal(status, F_none);
assert_int_equal(data.used, length);
f_array_lengthss_t data = f_array_lengths_t_initialize;
{
- const f_status_t status = f_type_array_lengthss_resize(length, &data);
+ const f_status_t status = f_array_lengthss_resize(length, &data);
assert_int_equal(status, F_none);
assert_int_equal(data.used, 0);
}
{
- const f_status_t status = f_type_array_lengthss_increase(length, &data);
+ const f_status_t status = f_array_lengthss_increase(length, &data);
assert_int_equal(status, F_data_not);
assert_int_equal(data.used, 0);
f_array_lengthss_t data = f_array_lengths_t_initialize;
{
- const f_status_t status = f_type_array_lengthss_increase(length, 0);
+ const f_status_t status = f_array_lengthss_increase(length, 0);
assert_int_equal(status, F_status_set_error(F_parameter));
assert_int_equal(data.used, 0);
f_array_lengthss_t data = f_array_lengths_t_initialize;
{
- const f_status_t status = f_type_array_lengthss_resize(length, &data);
+ const f_status_t status = f_array_lengthss_resize(length, &data);
assert_int_equal(status, F_none);
assert_int_equal(data.used, 0);
{
data.used = length;
- const f_status_t status = f_type_array_lengthss_increase_by(length, &data);
+ const f_status_t status = f_array_lengthss_increase_by(length, &data);
assert_int_equal(status, F_none);
assert_int_equal(data.used, length);
f_array_lengthss_t data = f_array_lengths_t_initialize;
{
- const f_status_t status = f_type_array_lengthss_increase_by(length, 0);
+ const f_status_t status = f_array_lengthss_increase_by(length, 0);
assert_int_equal(status, F_status_set_error(F_parameter));
assert_int_equal(data.used, 0);
f_array_lengthss_t data = f_array_lengthss_t_initialize;
{
- const f_status_t status = f_type_array_lengthss_resize(length, &data);
+ const f_status_t status = f_array_lengthss_resize(length, &data);
assert_int_equal(status, F_none);
assert_int_equal(data.used, 0);
f_array_lengthss_t data = f_array_lengthss_t_initialize;
{
- const f_status_t status = f_type_array_lengthss_resize(length, 0);
+ const f_status_t status = f_array_lengthss_resize(length, 0);
assert_int_equal(status, F_status_set_error(F_parameter));
assert_int_equal(data.used, 0);
f_cells_t data = f_cells_t_initialize;
{
- const f_status_t status = f_type_cells_adjust(length, &data);
+ const f_status_t status = f_cells_adjust(length, &data);
assert_int_equal(status, F_none);
assert_int_equal(data.used, 0);
f_cells_t data = f_cells_t_initialize;
{
- const f_status_t status = f_type_cells_adjust(length, 0);
+ const f_status_t status = f_cells_adjust(length, 0);
assert_int_equal(status, F_status_set_error(F_parameter));
assert_int_equal(data.used, 0);
const f_cell_t cell_1 = { row: 3, column: 4 };
{
- const f_status_t status = f_type_cells_resize(length, &source);
+ const f_status_t status = f_cells_resize(length, &source);
assert_int_equal(status, F_none);
assert_int_equal(source.used, 0);
memcpy(&source.array[source.used++], (void *) &cell_1, sizeof(f_cell_t));
{
- const f_status_t status = f_type_cells_append(source, &destination);
+ const f_status_t status = f_cells_append(source, &destination);
assert_int_equal(status, F_none);
assert_int_equal(destination.used, source.used);
f_cells_t destination = f_cells_t_initialize;
{
- const f_status_t status = f_type_cells_resize(length, &source);
+ const f_status_t status = f_cells_resize(length, &source);
assert_int_equal(status, F_none);
assert_int_equal(source.used, 0);
}
{
- const f_status_t status = f_type_cells_append(source, &destination);
+ const f_status_t status = f_cells_append(source, &destination);
assert_int_equal(status, F_data_not);
assert_int_equal(destination.used, 0);
f_cells_t data = f_cells_t_initialize;
{
- const f_status_t status = f_type_cells_append(data, 0);
+ const f_status_t status = f_cells_append(data, 0);
assert_int_equal(status, F_status_set_error(F_parameter));
assert_int_equal(data.used, 0);
f_cells_t data = f_cells_t_initialize;
{
- const f_status_t status = f_type_cells_resize(length, &data);
+ const f_status_t status = f_cells_resize(length, &data);
assert_int_equal(status, F_none);
assert_int_equal(data.used, 0);
}
{
- const f_status_t status = f_type_cells_decimate_by(length, &data);
+ const f_status_t status = f_cells_decimate_by(length, &data);
assert_int_equal(status, F_none);
assert_int_equal(data.used, 0);
f_cells_t data = f_cells_t_initialize;
{
- const f_status_t status = f_type_cells_decimate_by(length, 0);
+ const f_status_t status = f_cells_decimate_by(length, 0);
assert_int_equal(status, F_status_set_error(F_parameter));
assert_int_equal(data.used, 0);
f_cells_t data = f_cells_t_initialize;
{
- const f_status_t status = f_type_cells_resize(length, &data);
+ const f_status_t status = f_cells_resize(length, &data);
assert_int_equal(status, F_none);
assert_int_equal(data.used, 0);
}
{
- const f_status_t status = f_type_cells_decrease_by(length, &data);
+ const f_status_t status = f_cells_decrease_by(length, &data);
assert_int_equal(status, F_none);
assert_int_equal(data.used, 0);
f_cells_t data = f_cells_t_initialize;
{
- const f_status_t status = f_type_cells_decrease_by(length, 0);
+ const f_status_t status = f_cells_decrease_by(length, 0);
assert_int_equal(status, F_status_set_error(F_parameter));
assert_int_equal(data.used, 0);
f_cells_t data = f_cells_t_initialize;
{
- const f_status_t status = f_type_cells_resize(length, &data);
+ const f_status_t status = f_cells_resize(length, &data);
assert_int_equal(status, F_none);
assert_int_equal(data.used, 0);
{
data.used = length;
- const f_status_t status = f_type_cells_increase(length, &data);
+ const f_status_t status = f_cells_increase(length, &data);
assert_int_equal(status, F_none);
assert_int_equal(data.used, length);
f_cells_t data = f_cells_t_initialize;
{
- const f_status_t status = f_type_cells_resize(length, &data);
+ const f_status_t status = f_cells_resize(length, &data);
assert_int_equal(status, F_none);
assert_int_equal(data.used, 0);
}
{
- const f_status_t status = f_type_cells_increase(length, &data);
+ const f_status_t status = f_cells_increase(length, &data);
assert_int_equal(status, F_data_not);
assert_int_equal(data.used, 0);
f_cells_t data = f_cells_t_initialize;
{
- const f_status_t status = f_type_cells_increase(length, 0);
+ const f_status_t status = f_cells_increase(length, 0);
assert_int_equal(status, F_status_set_error(F_parameter));
assert_int_equal(data.used, 0);
f_cells_t data = f_cells_t_initialize;
{
- const f_status_t status = f_type_cells_resize(length, &data);
+ const f_status_t status = f_cells_resize(length, &data);
assert_int_equal(status, F_none);
assert_int_equal(data.used, 0);
{
data.used = length;
- const f_status_t status = f_type_cells_increase_by(length, &data);
+ const f_status_t status = f_cells_increase_by(length, &data);
assert_int_equal(status, F_none);
assert_int_equal(data.used, length);
f_cells_t data = f_cells_t_initialize;
{
- const f_status_t status = f_type_cells_increase_by(length, 0);
+ const f_status_t status = f_cells_increase_by(length, 0);
assert_int_equal(status, F_status_set_error(F_parameter));
assert_int_equal(data.used, 0);
f_cells_t data = f_cells_t_initialize;
{
- const f_status_t status = f_type_cells_resize(length, &data);
+ const f_status_t status = f_cells_resize(length, &data);
assert_int_equal(status, F_none);
assert_int_equal(data.used, 0);
f_cells_t data = f_cells_t_initialize;
{
- const f_status_t status = f_type_cells_resize(length, 0);
+ const f_status_t status = f_cells_resize(length, 0);
assert_int_equal(status, F_status_set_error(F_parameter));
assert_int_equal(data.used, 0);
f_cellss_t data = f_cellss_t_initialize;
{
- const f_status_t status = f_type_cellss_adjust(length, &data);
+ const f_status_t status = f_cellss_adjust(length, &data);
assert_int_equal(status, F_none);
assert_int_equal(data.used, 0);
f_cellss_t data = f_cellss_t_initialize;
{
- const f_status_t status = f_type_cellss_adjust(length, 0);
+ const f_status_t status = f_cellss_adjust(length, 0);
assert_int_equal(status, F_status_set_error(F_parameter));
assert_int_equal(data.used, 0);
const f_cell_t cell_1 = { row: 3, column: 4 };
{
- const f_status_t status = f_type_cellss_resize(length, &source);
+ const f_status_t status = f_cellss_resize(length, &source);
assert_int_equal(status, F_none);
assert_int_equal(source.used, 0);
{
for (; source.used < length; ++source.used) {
- const f_status_t status = f_type_cells_resize(length_inner, &source.array[source.used]);
+ const f_status_t status = f_cells_resize(length_inner, &source.array[source.used]);
assert_int_equal(status, F_none);
}
{
- const f_status_t status = f_type_cellss_append(source, &destination);
+ const f_status_t status = f_cellss_append(source, &destination);
assert_int_equal(status, F_none);
assert_int_equal(destination.used, source.used);
f_cellss_t destination = f_cells_t_initialize;
{
- const f_status_t status = f_type_cellss_resize(length, &source);
+ const f_status_t status = f_cellss_resize(length, &source);
assert_int_equal(status, F_none);
assert_int_equal(source.used, 0);
}
{
- const f_status_t status = f_type_cellss_append(source, &destination);
+ const f_status_t status = f_cellss_append(source, &destination);
assert_int_equal(status, F_data_not);
assert_int_equal(destination.used, 0);
f_cellss_t data = f_cells_t_initialize;
{
- const f_status_t status = f_type_cellss_append(data, 0);
+ const f_status_t status = f_cellss_append(data, 0);
assert_int_equal(status, F_status_set_error(F_parameter));
assert_int_equal(data.used, 0);
f_cellss_t data = f_cells_t_initialize;
{
- const f_status_t status = f_type_cellss_resize(length, &data);
+ const f_status_t status = f_cellss_resize(length, &data);
assert_int_equal(status, F_none);
assert_int_equal(data.used, 0);
}
{
- const f_status_t status = f_type_cellss_decimate_by(length, &data);
+ const f_status_t status = f_cellss_decimate_by(length, &data);
assert_int_equal(status, F_none);
assert_int_equal(data.used, 0);
f_cellss_t data = f_cells_t_initialize;
{
- const f_status_t status = f_type_cellss_decimate_by(length, 0);
+ const f_status_t status = f_cellss_decimate_by(length, 0);
assert_int_equal(status, F_status_set_error(F_parameter));
assert_int_equal(data.used, 0);
f_cellss_t data = f_cells_t_initialize;
{
- const f_status_t status = f_type_cellss_resize(length, &data);
+ const f_status_t status = f_cellss_resize(length, &data);
assert_int_equal(status, F_none);
assert_int_equal(data.used, 0);
}
{
- const f_status_t status = f_type_cellss_decrease_by(length, &data);
+ const f_status_t status = f_cellss_decrease_by(length, &data);
assert_int_equal(status, F_none);
assert_int_equal(data.used, 0);
f_cellss_t data = f_cells_t_initialize;
{
- const f_status_t status = f_type_cellss_decrease_by(length, 0);
+ const f_status_t status = f_cellss_decrease_by(length, 0);
assert_int_equal(status, F_status_set_error(F_parameter));
assert_int_equal(data.used, 0);
f_cellss_t data = f_cells_t_initialize;
{
- const f_status_t status = f_type_cellss_resize(length, &data);
+ const f_status_t status = f_cellss_resize(length, &data);
assert_int_equal(status, F_none);
assert_int_equal(data.used, 0);
{
data.used = length;
- const f_status_t status = f_type_cellss_increase(length, &data);
+ const f_status_t status = f_cellss_increase(length, &data);
assert_int_equal(status, F_none);
assert_int_equal(data.used, length);
f_cellss_t data = f_cells_t_initialize;
{
- const f_status_t status = f_type_cellss_resize(length, &data);
+ const f_status_t status = f_cellss_resize(length, &data);
assert_int_equal(status, F_none);
assert_int_equal(data.used, 0);
}
{
- const f_status_t status = f_type_cellss_increase(length, &data);
+ const f_status_t status = f_cellss_increase(length, &data);
assert_int_equal(status, F_data_not);
assert_int_equal(data.used, 0);
f_cellss_t data = f_cells_t_initialize;
{
- const f_status_t status = f_type_cellss_increase(length, 0);
+ const f_status_t status = f_cellss_increase(length, 0);
assert_int_equal(status, F_status_set_error(F_parameter));
assert_int_equal(data.used, 0);
f_cellss_t data = f_cells_t_initialize;
{
- const f_status_t status = f_type_cellss_resize(length, &data);
+ const f_status_t status = f_cellss_resize(length, &data);
assert_int_equal(status, F_none);
assert_int_equal(data.used, 0);
{
data.used = length;
- const f_status_t status = f_type_cellss_increase_by(length, &data);
+ const f_status_t status = f_cellss_increase_by(length, &data);
assert_int_equal(status, F_none);
assert_int_equal(data.used, length);
f_cellss_t data = f_cells_t_initialize;
{
- const f_status_t status = f_type_cellss_increase_by(length, 0);
+ const f_status_t status = f_cellss_increase_by(length, 0);
assert_int_equal(status, F_status_set_error(F_parameter));
assert_int_equal(data.used, 0);
f_cellss_t data = f_cellss_t_initialize;
{
- const f_status_t status = f_type_cellss_resize(length, &data);
+ const f_status_t status = f_cellss_resize(length, &data);
assert_int_equal(status, F_none);
assert_int_equal(data.used, 0);
f_cellss_t data = f_cellss_t_initialize;
{
- const f_status_t status = f_type_cellss_resize(length, 0);
+ const f_status_t status = f_cellss_resize(length, 0);
assert_int_equal(status, F_status_set_error(F_parameter));
assert_int_equal(data.used, 0);
f_fll_ids_t data = f_fll_ids_t_initialize;
{
- const f_status_t status = f_type_fll_ids_adjust(length, &data);
+ const f_status_t status = f_fll_ids_adjust(length, &data);
assert_int_equal(status, F_none);
assert_int_equal(data.used, 0);
f_fll_ids_t data = f_fll_ids_t_initialize;
{
- const f_status_t status = f_type_fll_ids_adjust(length, 0);
+ const f_status_t status = f_fll_ids_adjust(length, 0);
assert_int_equal(status, F_status_set_error(F_parameter));
assert_int_equal(data.used, 0);
const f_fll_id_t fll_id_1 = { name: "other", type: 2, used: 5 };
{
- const f_status_t status = f_type_fll_ids_resize(length, &source);
+ const f_status_t status = f_fll_ids_resize(length, &source);
assert_int_equal(status, F_none);
assert_int_equal(source.used, 0);
memcpy(&source.array[source.used++], (void *) &fll_id_1, sizeof(f_fll_id_t));
{
- const f_status_t status = f_type_fll_ids_append(source, &destination);
+ const f_status_t status = f_fll_ids_append(source, &destination);
assert_int_equal(status, F_none);
assert_int_equal(destination.used, source.used);
f_fll_ids_t destination = f_fll_ids_t_initialize;
{
- const f_status_t status = f_type_fll_ids_resize(length, &source);
+ const f_status_t status = f_fll_ids_resize(length, &source);
assert_int_equal(status, F_none);
assert_int_equal(source.used, 0);
}
{
- const f_status_t status = f_type_fll_ids_append(source, &destination);
+ const f_status_t status = f_fll_ids_append(source, &destination);
assert_int_equal(status, F_data_not);
assert_int_equal(destination.used, 0);
f_fll_ids_t data = f_fll_ids_t_initialize;
{
- const f_status_t status = f_type_fll_ids_append(data, 0);
+ const f_status_t status = f_fll_ids_append(data, 0);
assert_int_equal(status, F_status_set_error(F_parameter));
assert_int_equal(data.used, 0);
f_fll_ids_t data = f_fll_ids_t_initialize;
{
- const f_status_t status = f_type_fll_ids_resize(length, &data);
+ const f_status_t status = f_fll_ids_resize(length, &data);
assert_int_equal(status, F_none);
assert_int_equal(data.used, 0);
}
{
- const f_status_t status = f_type_fll_ids_decimate_by(length, &data);
+ const f_status_t status = f_fll_ids_decimate_by(length, &data);
assert_int_equal(status, F_none);
assert_int_equal(data.used, 0);
f_fll_ids_t data = f_fll_ids_t_initialize;
{
- const f_status_t status = f_type_fll_ids_decimate_by(length, 0);
+ const f_status_t status = f_fll_ids_decimate_by(length, 0);
assert_int_equal(status, F_status_set_error(F_parameter));
assert_int_equal(data.used, 0);
f_fll_ids_t data = f_fll_ids_t_initialize;
{
- const f_status_t status = f_type_fll_ids_resize(length, &data);
+ const f_status_t status = f_fll_ids_resize(length, &data);
assert_int_equal(status, F_none);
assert_int_equal(data.used, 0);
}
{
- const f_status_t status = f_type_fll_ids_decrease_by(length, &data);
+ const f_status_t status = f_fll_ids_decrease_by(length, &data);
assert_int_equal(status, F_none);
assert_int_equal(data.used, 0);
f_fll_ids_t data = f_fll_ids_t_initialize;
{
- const f_status_t status = f_type_fll_ids_decrease_by(length, 0);
+ const f_status_t status = f_fll_ids_decrease_by(length, 0);
assert_int_equal(status, F_status_set_error(F_parameter));
assert_int_equal(data.used, 0);
f_fll_ids_t data = f_fll_ids_t_initialize;
{
- const f_status_t status = f_type_fll_ids_resize(length, &data);
+ const f_status_t status = f_fll_ids_resize(length, &data);
assert_int_equal(status, F_none);
assert_int_equal(data.used, 0);
{
data.used = length;
- const f_status_t status = f_type_fll_ids_increase(length, &data);
+ const f_status_t status = f_fll_ids_increase(length, &data);
assert_int_equal(status, F_none);
assert_int_equal(data.used, length);
f_fll_ids_t data = f_fll_ids_t_initialize;
{
- const f_status_t status = f_type_fll_ids_resize(length, &data);
+ const f_status_t status = f_fll_ids_resize(length, &data);
assert_int_equal(status, F_none);
assert_int_equal(data.used, 0);
}
{
- const f_status_t status = f_type_fll_ids_increase(length, &data);
+ const f_status_t status = f_fll_ids_increase(length, &data);
assert_int_equal(status, F_data_not);
assert_int_equal(data.used, 0);
f_fll_ids_t data = f_fll_ids_t_initialize;
{
- const f_status_t status = f_type_fll_ids_increase(length, 0);
+ const f_status_t status = f_fll_ids_increase(length, 0);
assert_int_equal(status, F_status_set_error(F_parameter));
assert_int_equal(data.used, 0);
f_fll_ids_t data = f_fll_ids_t_initialize;
{
- const f_status_t status = f_type_fll_ids_resize(length, &data);
+ const f_status_t status = f_fll_ids_resize(length, &data);
assert_int_equal(status, F_none);
assert_int_equal(data.used, 0);
{
data.used = length;
- const f_status_t status = f_type_fll_ids_increase_by(length, &data);
+ const f_status_t status = f_fll_ids_increase_by(length, &data);
assert_int_equal(status, F_none);
assert_int_equal(data.used, length);
f_fll_ids_t data = f_fll_ids_t_initialize;
{
- const f_status_t status = f_type_fll_ids_increase_by(length, 0);
+ const f_status_t status = f_fll_ids_increase_by(length, 0);
assert_int_equal(status, F_status_set_error(F_parameter));
assert_int_equal(data.used, 0);
f_fll_ids_t data = f_fll_ids_t_initialize;
{
- const f_status_t status = f_type_fll_ids_resize(length, &data);
+ const f_status_t status = f_fll_ids_resize(length, &data);
assert_int_equal(status, F_none);
assert_int_equal(data.used, 0);
f_fll_ids_t data = f_fll_ids_t_initialize;
{
- const f_status_t status = f_type_fll_ids_resize(length, 0);
+ const f_status_t status = f_fll_ids_resize(length, 0);
assert_int_equal(status, F_status_set_error(F_parameter));
assert_int_equal(data.used, 0);
f_fll_idss_t data = f_fll_idss_t_initialize;
{
- const f_status_t status = f_type_fll_idss_adjust(length, &data);
+ const f_status_t status = f_fll_idss_adjust(length, &data);
assert_int_equal(status, F_none);
assert_int_equal(data.used, 0);
f_fll_idss_t data = f_fll_idss_t_initialize;
{
- const f_status_t status = f_type_fll_idss_adjust(length, 0);
+ const f_status_t status = f_fll_idss_adjust(length, 0);
assert_int_equal(status, F_status_set_error(F_parameter));
assert_int_equal(data.used, 0);
const f_fll_id_t fll_id_1 = { name: "other", type: 2, used: 5 };
{
- const f_status_t status = f_type_fll_idss_resize(length, &source);
+ const f_status_t status = f_fll_idss_resize(length, &source);
assert_int_equal(status, F_none);
assert_int_equal(source.used, 0);
{
for (; source.used < length; ++source.used) {
- const f_status_t status = f_type_fll_ids_resize(length_inner, &source.array[source.used]);
+ const f_status_t status = f_fll_ids_resize(length_inner, &source.array[source.used]);
assert_int_equal(status, F_none);
}
{
- const f_status_t status = f_type_fll_idss_append(source, &destination);
+ const f_status_t status = f_fll_idss_append(source, &destination);
assert_int_equal(status, F_none);
assert_int_equal(destination.used, source.used);
f_fll_idss_t destination = f_fll_ids_t_initialize;
{
- const f_status_t status = f_type_fll_idss_resize(length, &source);
+ const f_status_t status = f_fll_idss_resize(length, &source);
assert_int_equal(status, F_none);
assert_int_equal(source.used, 0);
}
{
- const f_status_t status = f_type_fll_idss_append(source, &destination);
+ const f_status_t status = f_fll_idss_append(source, &destination);
assert_int_equal(status, F_data_not);
assert_int_equal(destination.used, 0);
f_fll_idss_t data = f_fll_ids_t_initialize;
{
- const f_status_t status = f_type_fll_idss_append(data, 0);
+ const f_status_t status = f_fll_idss_append(data, 0);
assert_int_equal(status, F_status_set_error(F_parameter));
assert_int_equal(data.used, 0);
f_fll_idss_t data = f_fll_ids_t_initialize;
{
- const f_status_t status = f_type_fll_idss_resize(length, &data);
+ const f_status_t status = f_fll_idss_resize(length, &data);
assert_int_equal(status, F_none);
assert_int_equal(data.used, 0);
}
{
- const f_status_t status = f_type_fll_idss_decimate_by(length, &data);
+ const f_status_t status = f_fll_idss_decimate_by(length, &data);
assert_int_equal(status, F_none);
assert_int_equal(data.used, 0);
f_fll_idss_t data = f_fll_ids_t_initialize;
{
- const f_status_t status = f_type_fll_idss_decimate_by(length, 0);
+ const f_status_t status = f_fll_idss_decimate_by(length, 0);
assert_int_equal(status, F_status_set_error(F_parameter));
assert_int_equal(data.used, 0);
f_fll_idss_t data = f_fll_ids_t_initialize;
{
- const f_status_t status = f_type_fll_idss_resize(length, &data);
+ const f_status_t status = f_fll_idss_resize(length, &data);
assert_int_equal(status, F_none);
assert_int_equal(data.used, 0);
}
{
- const f_status_t status = f_type_fll_idss_decrease_by(length, &data);
+ const f_status_t status = f_fll_idss_decrease_by(length, &data);
assert_int_equal(status, F_none);
assert_int_equal(data.used, 0);
f_fll_idss_t data = f_fll_ids_t_initialize;
{
- const f_status_t status = f_type_fll_idss_decrease_by(length, 0);
+ const f_status_t status = f_fll_idss_decrease_by(length, 0);
assert_int_equal(status, F_status_set_error(F_parameter));
assert_int_equal(data.used, 0);
f_fll_idss_t data = f_fll_ids_t_initialize;
{
- const f_status_t status = f_type_fll_idss_resize(length, &data);
+ const f_status_t status = f_fll_idss_resize(length, &data);
assert_int_equal(status, F_none);
assert_int_equal(data.used, 0);
{
data.used = length;
- const f_status_t status = f_type_fll_idss_increase(length, &data);
+ const f_status_t status = f_fll_idss_increase(length, &data);
assert_int_equal(status, F_none);
assert_int_equal(data.used, length);
f_fll_idss_t data = f_fll_ids_t_initialize;
{
- const f_status_t status = f_type_fll_idss_resize(length, &data);
+ const f_status_t status = f_fll_idss_resize(length, &data);
assert_int_equal(status, F_none);
assert_int_equal(data.used, 0);
}
{
- const f_status_t status = f_type_fll_idss_increase(length, &data);
+ const f_status_t status = f_fll_idss_increase(length, &data);
assert_int_equal(status, F_data_not);
assert_int_equal(data.used, 0);
f_fll_idss_t data = f_fll_ids_t_initialize;
{
- const f_status_t status = f_type_fll_idss_increase(length, 0);
+ const f_status_t status = f_fll_idss_increase(length, 0);
assert_int_equal(status, F_status_set_error(F_parameter));
assert_int_equal(data.used, 0);
f_fll_idss_t data = f_fll_ids_t_initialize;
{
- const f_status_t status = f_type_fll_idss_resize(length, &data);
+ const f_status_t status = f_fll_idss_resize(length, &data);
assert_int_equal(status, F_none);
assert_int_equal(data.used, 0);
{
data.used = length;
- const f_status_t status = f_type_fll_idss_increase_by(length, &data);
+ const f_status_t status = f_fll_idss_increase_by(length, &data);
assert_int_equal(status, F_none);
assert_int_equal(data.used, length);
f_fll_idss_t data = f_fll_ids_t_initialize;
{
- const f_status_t status = f_type_fll_idss_increase_by(length, 0);
+ const f_status_t status = f_fll_idss_increase_by(length, 0);
assert_int_equal(status, F_status_set_error(F_parameter));
assert_int_equal(data.used, 0);
f_fll_idss_t data = f_fll_idss_t_initialize;
{
- const f_status_t status = f_type_fll_idss_resize(length, &data);
+ const f_status_t status = f_fll_idss_resize(length, &data);
assert_int_equal(status, F_none);
assert_int_equal(data.used, 0);
f_fll_idss_t data = f_fll_idss_t_initialize;
{
- const f_status_t status = f_type_fll_idss_resize(length, 0);
+ const f_status_t status = f_fll_idss_resize(length, 0);
assert_int_equal(status, F_status_set_error(F_parameter));
assert_int_equal(data.used, 0);
f_states_t data = f_states_t_initialize;
{
- const f_status_t status = f_type_states_adjust(length, &data);
+ const f_status_t status = f_states_adjust(length, &data);
assert_int_equal(status, F_none);
assert_int_equal(data.used, 0);
f_states_t data = f_states_t_initialize;
{
- const f_status_t status = f_type_states_adjust(length, 0);
+ const f_status_t status = f_states_adjust(length, 0);
assert_int_equal(status, F_status_set_error(F_parameter));
assert_int_equal(data.used, 0);
const f_state_t state_1 = { step_large: 20, step_small: 2, handle: 0, interrupt: 0, callbacks: 0, custom: 0, data: 0 };
{
- const f_status_t status = f_type_states_resize(length, &source);
+ const f_status_t status = f_states_resize(length, &source);
assert_int_equal(status, F_none);
assert_int_equal(source.used, 0);
memcpy(&source.array[source.used++], (void *) &state_1, sizeof(f_state_t));
{
- const f_status_t status = f_type_states_append(source, &destination);
+ const f_status_t status = f_states_append(source, &destination);
assert_int_equal(status, F_none);
assert_int_equal(destination.used, source.used);
f_states_t destination = f_states_t_initialize;
{
- const f_status_t status = f_type_states_resize(length, &source);
+ const f_status_t status = f_states_resize(length, &source);
assert_int_equal(status, F_none);
assert_int_equal(source.used, 0);
}
{
- const f_status_t status = f_type_states_append(source, &destination);
+ const f_status_t status = f_states_append(source, &destination);
assert_int_equal(status, F_data_not);
assert_int_equal(destination.used, 0);
f_states_t data = f_states_t_initialize;
{
- const f_status_t status = f_type_states_append(data, 0);
+ const f_status_t status = f_states_append(data, 0);
assert_int_equal(status, F_status_set_error(F_parameter));
assert_int_equal(data.used, 0);
f_states_t data = f_states_t_initialize;
{
- const f_status_t status = f_type_states_resize(length, &data);
+ const f_status_t status = f_states_resize(length, &data);
assert_int_equal(status, F_none);
assert_int_equal(data.used, 0);
}
{
- const f_status_t status = f_type_states_decimate_by(length, &data);
+ const f_status_t status = f_states_decimate_by(length, &data);
assert_int_equal(status, F_none);
assert_int_equal(data.used, 0);
f_states_t data = f_states_t_initialize;
{
- const f_status_t status = f_type_states_decimate_by(length, 0);
+ const f_status_t status = f_states_decimate_by(length, 0);
assert_int_equal(status, F_status_set_error(F_parameter));
assert_int_equal(data.used, 0);
f_states_t data = f_states_t_initialize;
{
- const f_status_t status = f_type_states_resize(length, &data);
+ const f_status_t status = f_states_resize(length, &data);
assert_int_equal(status, F_none);
assert_int_equal(data.used, 0);
}
{
- const f_status_t status = f_type_states_decrease_by(length, &data);
+ const f_status_t status = f_states_decrease_by(length, &data);
assert_int_equal(status, F_none);
assert_int_equal(data.used, 0);
f_states_t data = f_states_t_initialize;
{
- const f_status_t status = f_type_states_decrease_by(length, 0);
+ const f_status_t status = f_states_decrease_by(length, 0);
assert_int_equal(status, F_status_set_error(F_parameter));
assert_int_equal(data.used, 0);
f_states_t data = f_states_t_initialize;
{
- const f_status_t status = f_type_states_resize(length, &data);
+ const f_status_t status = f_states_resize(length, &data);
assert_int_equal(status, F_none);
assert_int_equal(data.used, 0);
{
data.used = length;
- const f_status_t status = f_type_states_increase(length, &data);
+ const f_status_t status = f_states_increase(length, &data);
assert_int_equal(status, F_none);
assert_int_equal(data.used, length);
f_states_t data = f_states_t_initialize;
{
- const f_status_t status = f_type_states_resize(length, &data);
+ const f_status_t status = f_states_resize(length, &data);
assert_int_equal(status, F_none);
assert_int_equal(data.used, 0);
}
{
- const f_status_t status = f_type_states_increase(length, &data);
+ const f_status_t status = f_states_increase(length, &data);
assert_int_equal(status, F_data_not);
assert_int_equal(data.used, 0);
f_states_t data = f_states_t_initialize;
{
- const f_status_t status = f_type_states_increase(length, 0);
+ const f_status_t status = f_states_increase(length, 0);
assert_int_equal(status, F_status_set_error(F_parameter));
assert_int_equal(data.used, 0);
f_states_t data = f_states_t_initialize;
{
- const f_status_t status = f_type_states_resize(length, &data);
+ const f_status_t status = f_states_resize(length, &data);
assert_int_equal(status, F_none);
assert_int_equal(data.used, 0);
{
data.used = length;
- const f_status_t status = f_type_states_increase_by(length, &data);
+ const f_status_t status = f_states_increase_by(length, &data);
assert_int_equal(status, F_none);
assert_int_equal(data.used, length);
f_states_t data = f_states_t_initialize;
{
- const f_status_t status = f_type_states_increase_by(length, 0);
+ const f_status_t status = f_states_increase_by(length, 0);
assert_int_equal(status, F_status_set_error(F_parameter));
assert_int_equal(data.used, 0);
f_states_t data = f_states_t_initialize;
{
- const f_status_t status = f_type_states_resize(length, &data);
+ const f_status_t status = f_states_resize(length, &data);
assert_int_equal(status, F_none);
assert_int_equal(data.used, 0);
f_states_t data = f_states_t_initialize;
{
- const f_status_t status = f_type_states_resize(length, 0);
+ const f_status_t status = f_states_resize(length, 0);
assert_int_equal(status, F_status_set_error(F_parameter));
assert_int_equal(data.used, 0);
f_statess_t data = f_statess_t_initialize;
{
- const f_status_t status = f_type_statess_adjust(length, &data);
+ const f_status_t status = f_statess_adjust(length, &data);
assert_int_equal(status, F_none);
assert_int_equal(data.used, 0);
f_statess_t data = f_statess_t_initialize;
{
- const f_status_t status = f_type_statess_adjust(length, 0);
+ const f_status_t status = f_statess_adjust(length, 0);
assert_int_equal(status, F_status_set_error(F_parameter));
assert_int_equal(data.used, 0);
const f_state_t state_1 = { step_large: 20, step_small: 2, handle: 0, interrupt: 0, callbacks: 0, custom: 0, data: 0 };
{
- const f_status_t status = f_type_statess_resize(length, &source);
+ const f_status_t status = f_statess_resize(length, &source);
assert_int_equal(status, F_none);
assert_int_equal(source.used, 0);
{
for (; source.used < length; ++source.used) {
- const f_status_t status = f_type_states_resize(length_inner, &source.array[source.used]);
+ const f_status_t status = f_states_resize(length_inner, &source.array[source.used]);
assert_int_equal(status, F_none);
}
{
- const f_status_t status = f_type_statess_append(source, &destination);
+ const f_status_t status = f_statess_append(source, &destination);
assert_int_equal(status, F_none);
assert_int_equal(destination.used, source.used);
f_statess_t destination = f_states_t_initialize;
{
- const f_status_t status = f_type_statess_resize(length, &source);
+ const f_status_t status = f_statess_resize(length, &source);
assert_int_equal(status, F_none);
assert_int_equal(source.used, 0);
}
{
- const f_status_t status = f_type_statess_append(source, &destination);
+ const f_status_t status = f_statess_append(source, &destination);
assert_int_equal(status, F_data_not);
assert_int_equal(destination.used, 0);
f_statess_t data = f_states_t_initialize;
{
- const f_status_t status = f_type_statess_append(data, 0);
+ const f_status_t status = f_statess_append(data, 0);
assert_int_equal(status, F_status_set_error(F_parameter));
assert_int_equal(data.used, 0);
f_statess_t data = f_states_t_initialize;
{
- const f_status_t status = f_type_statess_resize(length, &data);
+ const f_status_t status = f_statess_resize(length, &data);
assert_int_equal(status, F_none);
assert_int_equal(data.used, 0);
}
{
- const f_status_t status = f_type_statess_decimate_by(length, &data);
+ const f_status_t status = f_statess_decimate_by(length, &data);
assert_int_equal(status, F_none);
assert_int_equal(data.used, 0);
f_statess_t data = f_states_t_initialize;
{
- const f_status_t status = f_type_statess_decimate_by(length, 0);
+ const f_status_t status = f_statess_decimate_by(length, 0);
assert_int_equal(status, F_status_set_error(F_parameter));
assert_int_equal(data.used, 0);
f_statess_t data = f_states_t_initialize;
{
- const f_status_t status = f_type_statess_resize(length, &data);
+ const f_status_t status = f_statess_resize(length, &data);
assert_int_equal(status, F_none);
assert_int_equal(data.used, 0);
}
{
- const f_status_t status = f_type_statess_decrease_by(length, &data);
+ const f_status_t status = f_statess_decrease_by(length, &data);
assert_int_equal(status, F_none);
assert_int_equal(data.used, 0);
f_statess_t data = f_states_t_initialize;
{
- const f_status_t status = f_type_statess_decrease_by(length, 0);
+ const f_status_t status = f_statess_decrease_by(length, 0);
assert_int_equal(status, F_status_set_error(F_parameter));
assert_int_equal(data.used, 0);
f_statess_t data = f_states_t_initialize;
{
- const f_status_t status = f_type_statess_resize(length, &data);
+ const f_status_t status = f_statess_resize(length, &data);
assert_int_equal(status, F_none);
assert_int_equal(data.used, 0);
{
data.used = length;
- const f_status_t status = f_type_statess_increase(length, &data);
+ const f_status_t status = f_statess_increase(length, &data);
assert_int_equal(status, F_none);
assert_int_equal(data.used, length);
f_statess_t data = f_states_t_initialize;
{
- const f_status_t status = f_type_statess_resize(length, &data);
+ const f_status_t status = f_statess_resize(length, &data);
assert_int_equal(status, F_none);
assert_int_equal(data.used, 0);
}
{
- const f_status_t status = f_type_statess_increase(length, &data);
+ const f_status_t status = f_statess_increase(length, &data);
assert_int_equal(status, F_data_not);
assert_int_equal(data.used, 0);
f_statess_t data = f_states_t_initialize;
{
- const f_status_t status = f_type_statess_increase(length, 0);
+ const f_status_t status = f_statess_increase(length, 0);
assert_int_equal(status, F_status_set_error(F_parameter));
assert_int_equal(data.used, 0);
f_statess_t data = f_states_t_initialize;
{
- const f_status_t status = f_type_statess_resize(length, &data);
+ const f_status_t status = f_statess_resize(length, &data);
assert_int_equal(status, F_none);
assert_int_equal(data.used, 0);
{
data.used = length;
- const f_status_t status = f_type_statess_increase_by(length, &data);
+ const f_status_t status = f_statess_increase_by(length, &data);
assert_int_equal(status, F_none);
assert_int_equal(data.used, length);
f_statess_t data = f_states_t_initialize;
{
- const f_status_t status = f_type_statess_increase_by(length, 0);
+ const f_status_t status = f_statess_increase_by(length, 0);
assert_int_equal(status, F_status_set_error(F_parameter));
assert_int_equal(data.used, 0);
f_statess_t data = f_statess_t_initialize;
{
- const f_status_t status = f_type_statess_resize(length, &data);
+ const f_status_t status = f_statess_resize(length, &data);
assert_int_equal(status, F_none);
assert_int_equal(data.used, 0);
f_statess_t data = f_statess_t_initialize;
{
- const f_status_t status = f_type_statess_resize(length, 0);
+ const f_status_t status = f_statess_resize(length, 0);
assert_int_equal(status, F_status_set_error(F_parameter));
assert_int_equal(data.used, 0);
f_statuss_t data = f_statuss_t_initialize;
{
- const f_status_t status = f_type_statuss_adjust(length, &data);
+ const f_status_t status = f_statuss_adjust(length, &data);
assert_int_equal(status, F_none);
assert_int_equal(data.used, 0);
f_statuss_t data = f_statuss_t_initialize;
{
- const f_status_t status = f_type_statuss_adjust(length, 0);
+ const f_status_t status = f_statuss_adjust(length, 0);
assert_int_equal(status, F_status_set_error(F_parameter));
assert_int_equal(data.used, 0);
f_statuss_t destination = f_statuss_t_initialize;
{
- const f_status_t status = f_type_statuss_resize(length, &source);
+ const f_status_t status = f_statuss_resize(length, &source);
assert_int_equal(status, F_none);
assert_int_equal(source.used, 0);
} // for
{
- const f_status_t status = f_type_statuss_append(source, &destination);
+ const f_status_t status = f_statuss_append(source, &destination);
assert_int_equal(status, F_none);
assert_int_equal(destination.used, source.used);
f_statuss_t destination = f_statuss_t_initialize;
{
- const f_status_t status = f_type_statuss_resize(length, &source);
+ const f_status_t status = f_statuss_resize(length, &source);
assert_int_equal(status, F_none);
assert_int_equal(source.used, 0);
}
{
- const f_status_t status = f_type_statuss_append(source, &destination);
+ const f_status_t status = f_statuss_append(source, &destination);
assert_int_equal(status, F_data_not);
assert_int_equal(destination.used, 0);
f_statuss_t data = f_statuss_t_initialize;
{
- const f_status_t status = f_type_statuss_append(data, 0);
+ const f_status_t status = f_statuss_append(data, 0);
assert_int_equal(status, F_status_set_error(F_parameter));
assert_int_equal(data.used, 0);
f_statuss_t data = f_statuss_t_initialize;
{
- const f_status_t status = f_type_statuss_resize(length, &data);
+ const f_status_t status = f_statuss_resize(length, &data);
assert_int_equal(status, F_none);
assert_int_equal(data.used, 0);
}
{
- const f_status_t status = f_type_statuss_decimate_by(length, &data);
+ const f_status_t status = f_statuss_decimate_by(length, &data);
assert_int_equal(status, F_none);
assert_int_equal(data.used, 0);
f_statuss_t data = f_statuss_t_initialize;
{
- const f_status_t status = f_type_statuss_decimate_by(length, 0);
+ const f_status_t status = f_statuss_decimate_by(length, 0);
assert_int_equal(status, F_status_set_error(F_parameter));
assert_int_equal(data.used, 0);
f_statuss_t data = f_statuss_t_initialize;
{
- const f_status_t status = f_type_statuss_resize(length, &data);
+ const f_status_t status = f_statuss_resize(length, &data);
assert_int_equal(status, F_none);
assert_int_equal(data.used, 0);
}
{
- const f_status_t status = f_type_statuss_decrease_by(length, &data);
+ const f_status_t status = f_statuss_decrease_by(length, &data);
assert_int_equal(status, F_none);
assert_int_equal(data.used, 0);
f_statuss_t data = f_statuss_t_initialize;
{
- const f_status_t status = f_type_statuss_decrease_by(length, 0);
+ const f_status_t status = f_statuss_decrease_by(length, 0);
assert_int_equal(status, F_status_set_error(F_parameter));
assert_int_equal(data.used, 0);
f_statuss_t data = f_statuss_t_initialize;
{
- const f_status_t status = f_type_statuss_resize(length, &data);
+ const f_status_t status = f_statuss_resize(length, &data);
assert_int_equal(status, F_none);
assert_int_equal(data.used, 0);
{
data.used = length;
- const f_status_t status = f_type_statuss_increase(length, &data);
+ const f_status_t status = f_statuss_increase(length, &data);
assert_int_equal(status, F_none);
assert_int_equal(data.used, length);
f_statuss_t data = f_statuss_t_initialize;
{
- const f_status_t status = f_type_statuss_resize(length, &data);
+ const f_status_t status = f_statuss_resize(length, &data);
assert_int_equal(status, F_none);
assert_int_equal(data.used, 0);
}
{
- const f_status_t status = f_type_statuss_increase(length, &data);
+ const f_status_t status = f_statuss_increase(length, &data);
assert_int_equal(status, F_data_not);
assert_int_equal(data.used, 0);
f_statuss_t data = f_statuss_t_initialize;
{
- const f_status_t status = f_type_statuss_increase(length, 0);
+ const f_status_t status = f_statuss_increase(length, 0);
assert_int_equal(status, F_status_set_error(F_parameter));
assert_int_equal(data.used, 0);
f_statuss_t data = f_statuss_t_initialize;
{
- const f_status_t status = f_type_statuss_resize(length, &data);
+ const f_status_t status = f_statuss_resize(length, &data);
assert_int_equal(status, F_none);
assert_int_equal(data.used, 0);
{
data.used = length;
- const f_status_t status = f_type_statuss_increase_by(length, &data);
+ const f_status_t status = f_statuss_increase_by(length, &data);
assert_int_equal(status, F_none);
assert_int_equal(data.used, length);
f_statuss_t data = f_statuss_t_initialize;
{
- const f_status_t status = f_type_statuss_increase_by(length, 0);
+ const f_status_t status = f_statuss_increase_by(length, 0);
assert_int_equal(status, F_status_set_error(F_parameter));
assert_int_equal(data.used, 0);
f_statuss_t data = f_statuss_t_initialize;
{
- const f_status_t status = f_type_statuss_resize(length, &data);
+ const f_status_t status = f_statuss_resize(length, &data);
assert_int_equal(status, F_none);
assert_int_equal(data.used, 0);
f_statuss_t data = f_statuss_t_initialize;
{
- const f_status_t status = f_type_statuss_resize(length, 0);
+ const f_status_t status = f_statuss_resize(length, 0);
assert_int_equal(status, F_status_set_error(F_parameter));
assert_int_equal(data.used, 0);
f_statusss_t data = f_statusss_t_initialize;
{
- const f_status_t status = f_type_statusss_adjust(length, &data);
+ const f_status_t status = f_statusss_adjust(length, &data);
assert_int_equal(status, F_none);
assert_int_equal(data.used, 0);
f_statusss_t data = f_statusss_t_initialize;
{
- const f_status_t status = f_type_statusss_adjust(length, 0);
+ const f_status_t status = f_statusss_adjust(length, 0);
assert_int_equal(status, F_status_set_error(F_parameter));
assert_int_equal(data.used, 0);
f_statusss_t destination = f_statuss_t_initialize;
{
- const f_status_t status = f_type_statusss_resize(length, &source);
+ const f_status_t status = f_statusss_resize(length, &source);
assert_int_equal(status, F_none);
assert_int_equal(source.used, 0);
{
for (; source.used < length; ++source.used) {
- const f_status_t status = f_type_statuss_resize(length_inner, &source.array[source.used]);
+ const f_status_t status = f_statuss_resize(length_inner, &source.array[source.used]);
assert_int_equal(status, F_none);
}
{
- const f_status_t status = f_type_statusss_append(source, &destination);
+ const f_status_t status = f_statusss_append(source, &destination);
assert_int_equal(status, F_none);
assert_int_equal(destination.used, source.used);
f_statusss_t destination = f_statuss_t_initialize;
{
- const f_status_t status = f_type_statusss_resize(length, &source);
+ const f_status_t status = f_statusss_resize(length, &source);
assert_int_equal(status, F_none);
assert_int_equal(source.used, 0);
}
{
- const f_status_t status = f_type_statusss_append(source, &destination);
+ const f_status_t status = f_statusss_append(source, &destination);
assert_int_equal(status, F_data_not);
assert_int_equal(destination.used, 0);
f_statusss_t data = f_statuss_t_initialize;
{
- const f_status_t status = f_type_statusss_append(data, 0);
+ const f_status_t status = f_statusss_append(data, 0);
assert_int_equal(status, F_status_set_error(F_parameter));
assert_int_equal(data.used, 0);
f_statusss_t data = f_statuss_t_initialize;
{
- const f_status_t status = f_type_statusss_resize(length, &data);
+ const f_status_t status = f_statusss_resize(length, &data);
assert_int_equal(status, F_none);
assert_int_equal(data.used, 0);
}
{
- const f_status_t status = f_type_statusss_decimate_by(length, &data);
+ const f_status_t status = f_statusss_decimate_by(length, &data);
assert_int_equal(status, F_none);
assert_int_equal(data.used, 0);
f_statusss_t data = f_statuss_t_initialize;
{
- const f_status_t status = f_type_statusss_decimate_by(length, 0);
+ const f_status_t status = f_statusss_decimate_by(length, 0);
assert_int_equal(status, F_status_set_error(F_parameter));
assert_int_equal(data.used, 0);
f_statusss_t data = f_statuss_t_initialize;
{
- const f_status_t status = f_type_statusss_resize(length, &data);
+ const f_status_t status = f_statusss_resize(length, &data);
assert_int_equal(status, F_none);
assert_int_equal(data.used, 0);
}
{
- const f_status_t status = f_type_statusss_decrease_by(length, &data);
+ const f_status_t status = f_statusss_decrease_by(length, &data);
assert_int_equal(status, F_none);
assert_int_equal(data.used, 0);
f_statusss_t data = f_statuss_t_initialize;
{
- const f_status_t status = f_type_statusss_decrease_by(length, 0);
+ const f_status_t status = f_statusss_decrease_by(length, 0);
assert_int_equal(status, F_status_set_error(F_parameter));
assert_int_equal(data.used, 0);
f_statusss_t data = f_statuss_t_initialize;
{
- const f_status_t status = f_type_statusss_resize(length, &data);
+ const f_status_t status = f_statusss_resize(length, &data);
assert_int_equal(status, F_none);
assert_int_equal(data.used, 0);
{
data.used = length;
- const f_status_t status = f_type_statusss_increase(length, &data);
+ const f_status_t status = f_statusss_increase(length, &data);
assert_int_equal(status, F_none);
assert_int_equal(data.used, length);
f_statusss_t data = f_statuss_t_initialize;
{
- const f_status_t status = f_type_statusss_resize(length, &data);
+ const f_status_t status = f_statusss_resize(length, &data);
assert_int_equal(status, F_none);
assert_int_equal(data.used, 0);
}
{
- const f_status_t status = f_type_statusss_increase(length, &data);
+ const f_status_t status = f_statusss_increase(length, &data);
assert_int_equal(status, F_data_not);
assert_int_equal(data.used, 0);
f_statusss_t data = f_statuss_t_initialize;
{
- const f_status_t status = f_type_statusss_increase(length, 0);
+ const f_status_t status = f_statusss_increase(length, 0);
assert_int_equal(status, F_status_set_error(F_parameter));
assert_int_equal(data.used, 0);
f_statusss_t data = f_statuss_t_initialize;
{
- const f_status_t status = f_type_statusss_resize(length, &data);
+ const f_status_t status = f_statusss_resize(length, &data);
assert_int_equal(status, F_none);
assert_int_equal(data.used, 0);
{
data.used = length;
- const f_status_t status = f_type_statusss_increase_by(length, &data);
+ const f_status_t status = f_statusss_increase_by(length, &data);
assert_int_equal(status, F_none);
assert_int_equal(data.used, length);
f_statusss_t data = f_statuss_t_initialize;
{
- const f_status_t status = f_type_statusss_increase_by(length, 0);
+ const f_status_t status = f_statusss_increase_by(length, 0);
assert_int_equal(status, F_status_set_error(F_parameter));
assert_int_equal(data.used, 0);
f_statusss_t data = f_statusss_t_initialize;
{
- const f_status_t status = f_type_statusss_resize(length, &data);
+ const f_status_t status = f_statusss_resize(length, &data);
assert_int_equal(status, F_none);
assert_int_equal(data.used, 0);
f_statusss_t data = f_statusss_t_initialize;
{
- const f_status_t status = f_type_statusss_resize(length, 0);
+ const f_status_t status = f_statusss_resize(length, 0);
assert_int_equal(status, F_status_set_error(F_parameter));
assert_int_equal(data.used, 0);
macro_f_fss_objects_t_resize(status, objects, state.step_small)
if (F_status_is_error(status)) {
- f_type_array_lengths_resize(0, &positions_start);
+ f_array_lengths_resize(0, &positions_start);
return status;
}
macro_f_array_lengths_t_resize(status, slashes, state.step_small)
if (F_status_is_error(status)) {
- f_type_array_lengths_resize(0, &positions_start);
+ f_array_lengths_resize(0, &positions_start);
macro_f_fss_objects_t_delete_simple(objects);
return status;
private_macro_fl_fss_nest_return_on_overflow_delimited((buffer), (*range), (*found), positions_start, objects, slashes, F_none_eos, F_none_stop)
- f_type_array_lengths_resize(0, &positions_start);
+ f_array_lengths_resize(0, &positions_start);
macro_f_fss_objects_t_delete_simple(objects);
- f_type_array_lengths_resize(0, &slashes);
+ f_array_lengths_resize(0, &slashes);
return F_fss_found_content;
}
if (F_status_is_error(status)) break;
} // while
- f_type_array_lengths_resize(0, &positions_start);
+ f_array_lengths_resize(0, &positions_start);
macro_f_fss_objects_t_delete_simple(objects);
- f_type_array_lengths_resize(0, &slashes);
+ f_array_lengths_resize(0, &slashes);
delimits->used = delimits_used;
comments->used = comments_used;
do {
if (ids && ids->used + 1 > ids->size) {
- status = f_type_fll_ids_increase(F_fss_default_allocation_step_small_d, ids);
+ status = f_fll_ids_increase(F_fss_default_allocation_step_small_d, ids);
}
if (F_status_is_error_not(status)) {
}
if (ids) {
- status = f_type_fll_ids_increase(F_fss_default_allocation_step_small_d, ids);
+ status = f_fll_ids_increase(F_fss_default_allocation_step_small_d, ids);
if (F_status_is_error(status)) {
if (ids) {
if (F_status_is_error(status)) return status;
if (indexs) {
- status = f_type_array_lengths_increase_by(content->used, indexs[j]);
+ status = f_array_lengths_increase_by(content->used, indexs[j]);
if (F_status_is_error(status)) return status;
}
}
*
* F_complete_not_utf (with error bit) if character is an incomplete UTF-8 fragment.
*
- * Errors (with error bit) from: f_type_fll_ids_increase().
+ * Errors (with error bit) from: f_fll_ids_increase().
* Errors (with error bit) from: f_utf_is_whitespace().
* Errors (with error bit) from: fl_string_fll_identify().
*
- * @see f_type_fll_ids_increase()
+ * @see f_fll_ids_increase()
* @see f_utf_is_whitespace()
* @see fl_string_fll_identify()
*/
if (F_status_is_error(status)) return status;
if (objects_quoted) {
- status = f_type_uint8s_increase(state.step_small, objects_quoted);
+ status = f_uint8s_increase(state.step_small, objects_quoted);
if (F_status_is_error(status)) return status;
}
if (F_status_is_error(status)) return status;
if (objects_quoted) {
- status = f_type_uint8s_increase(state.step_small, objects_quoted);
+ status = f_uint8s_increase(state.step_small, objects_quoted);
if (F_status_is_error(status)) return status;
}
if (contents_quoted) {
- status = f_type_uint8ss_increase(state.step_small, contents_quoted);
+ status = f_uint8ss_increase(state.step_small, contents_quoted);
if (F_status_is_error(status)) return status;
}
++contents->used;
if (contents_quoted) {
- status2 = f_type_uint8s_increase(state.step_small, &contents_quoted->array[contents_quoted->used]);
+ status2 = f_uint8s_increase(state.step_small, &contents_quoted->array[contents_quoted->used]);
if (F_status_is_error(status2)) return status2;
++contents_quoted->used;
found_data = F_true;
if (contents_quoted) {
- status2 = f_type_uint8s_increase(state.step_small, &contents_quoted->array[contents_quoted->used]);
+ status2 = f_uint8s_increase(state.step_small, &contents_quoted->array[contents_quoted->used]);
if (F_status_is_error(status2)) return status2;
quoted_content = &contents_quoted->array[contents_quoted->used];
f_string_ranges_resize(0, &objects);
f_string_rangess_resize(0, &contents);
- f_type_array_lengths_resize(0, &delimits);
+ f_array_lengths_resize(0, &delimits);
data->cache.buffer_large.used = 0;
data->cache.buffer_small.used = 0;
#ifndef _di_controller_cache_delete_simple_
void controller_cache_delete_simple(controller_cache_t * const cache) {
- f_type_array_lengths_resize(0, &cache->ats);
- f_type_array_lengths_resize(0, &cache->stack);
+ f_array_lengths_resize(0, &cache->ats);
+ f_array_lengths_resize(0, &cache->stack);
macro_f_fss_delimits_t_delete_simple(cache->delimits)
f_string_dynamic_resize(0, &cache->buffer_file);
f_string_dynamics_resize(0, &process->path_pids);
- f_type_array_lengths_resize(0, &process->stack);
+ f_array_lengths_resize(0, &process->stack);
}
#endif // _di_controller_process_delete_simple_
}
if (source.affinity.used) {
- status = f_type_int32s_append(source.affinity, &destination->affinity);
+ status = f_int32s_append(source.affinity, &destination->affinity);
if (F_status_is_error(status)) return status;
}
if (F_status_is_error(status)) return status;
if (source.groups.used) {
- status = f_type_int32s_append(source.groups, &destination->groups);
+ status = f_int32s_append(source.groups, &destination->groups);
if (F_status_is_error(status)) return status;
}
if (F_status_is_error_not(status) && stack.used) {
if (process->stack.size < stack.used) {
- status = f_type_array_lengths_resize(stack.used, &process->stack);
+ status = f_array_lengths_resize(stack.used, &process->stack);
}
if (F_status_is_error(status)) {
- controller_print_error(global.thread, global.main->error, F_status_set_fine(status), "f_type_array_lengths_resize", F_true);
+ controller_print_error(global.thread, global.main->error, F_status_set_fine(status), "f_array_lengths_resize", F_true);
}
else {
for (f_array_length_t i = 0; i < stack.used; ++i) {
}
if (F_status_is_error_not(status)) {
- status = f_type_array_lengths_increase(controller_common_allocation_small_d, &process->stack);
+ status = f_array_lengths_increase(controller_common_allocation_small_d, &process->stack);
if (F_status_is_error(status)) {
- controller_print_error(global.thread, global.main->error, F_status_set_fine(status), "f_type_array_lengths_increase", F_true);
+ controller_print_error(global.thread, global.main->error, F_status_set_fine(status), "f_array_lengths_increase", F_true);
}
else {
f_thread_unlock(&process->lock);
* Errors (with error bit) from: f_string_dynamic_append().
* Errors (with error bit) from: f_string_dynamics_append().
* Errors (with error bit) from: f_string_maps_append().
- * Errors (with error bit) from: f_type_int32s_append().
+ * Errors (with error bit) from: f_int32s_append().
*
* @see f_capability_copy()
* @see f_control_group_copy()
* @see f_string_dynamic_append()
* @see f_string_dynamics_append()
* @see f_string_maps_append()
- * @see f_type_int32s_append()
+ * @see f_int32s_append()
*/
#ifndef _di_controller_rule_copy_
extern f_status_t controller_rule_copy(const controller_rule_t source, controller_rule_t *destination) F_attribute_visibility_internal_d;
// Deallocate dynamic portions of the structure that are only ever needed while the process is running.
controller_cache_delete_simple(&process->cache);
- f_type_array_lengths_resize(0, &process->stack);
+ f_array_lengths_resize(0, &process->stack);
// Shrink the childs array.
if (process->childs.used) {
f_file_stream_close(F_true, &data_make.path.top);
- f_type_array_lengths_resize(0, §ion_stack);
+ f_array_lengths_resize(0, §ion_stack);
fake_make_data_delete(&data_make);
return status;
}
// Add the operation id to the operation stack.
- *status = f_type_array_lengths_increase(fake_default_allocation_small_d, section_stack);
+ *status = f_array_lengths_increase(fake_default_allocation_small_d, section_stack);
if (F_status_is_error(*status)) {
- fll_error_print(data_make->error, F_status_set_fine(*status), "f_type_array_lengths_increase", F_true);
+ fll_error_print(data_make->error, F_status_set_fine(*status), "f_array_lengths_increase", F_true);
return 0;
}
}
if (F_status_is_error(status)) {
- f_type_array_lengths_resize(0, &delimits);
+ f_array_lengths_resize(0, &delimits);
break;
}
status = fll_execute_program(current_tool, arguments, 0, 0, (void *) &return_code);
if (status == F_child) {
- f_type_array_lengths_resize(0, &delimits);
+ f_array_lengths_resize(0, &delimits);
f_string_dynamic_resize(0, &ip_list);
f_string_dynamics_resize(0, &arguments);
--arguments.used;
}
- f_type_array_lengths_resize(0, &delimits);
+ f_array_lengths_resize(0, &delimits);
}
}
local->chain = 0;
f_string_dynamic_resize(0, &local->buffer);
- f_type_array_lengths_resize(0, &local->chain_ids);
+ f_array_lengths_resize(0, &local->chain_ids);
f_string_ranges_resize(0, &local->chain_objects);
f_string_rangess_resize(0, &local->chain_contents);
if (F_status_is_error(status)) {
fll_error_file_print(main->error, F_status_set_fine(status), "fll_fss_identify", F_true, name.used ? name : f_string_ascii_pipe_s, f_file_operation_read_s, name.used ? fll_error_file_type_file_e : fll_error_file_type_pipe_e);
- f_type_fll_ids_resize(0, &ids);
+ f_fll_ids_resize(0, &ids);
return status;
}
} // for
}
- f_type_fll_ids_resize(0, &ids);
+ f_fll_ids_resize(0, &ids);
return F_none;
}
projects / fll / commitdiff