update stuff
This commit is contained in:
Maix0
parent
5973022688
commit
544ed8b045
194 changed files with 2060 additions and 1464 deletions
|
|
@ -25,16 +25,25 @@
|
|||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
/// @struct A key-value pair for the hashmap
|
||||
typedef struct s_kv_env
|
||||
{
|
||||
t_str key;
|
||||
t_str val;
|
||||
} t_kv_env;
|
||||
|
||||
/// @typedef A function that hashes a key
|
||||
typedef void (*t_hash_env_fn)(t_hasher *hasher, t_str *key);
|
||||
/// @typedef A function that drops a key-value pair
|
||||
typedef void (*t_drop_env_fn)(t_kv_env val);
|
||||
/// @typedef A function that compares two keys and returns true if they are equal
|
||||
typedef bool (*t_eq_env_fn)(t_str *lhs, t_str *rhs);
|
||||
|
||||
|
||||
/// @struct A single entry in the hashmap
|
||||
/// @var hash_id The hash of the key
|
||||
/// @var kv The key-value pair
|
||||
/// @var next The next entry in the bucket
|
||||
typedef struct s_entry_env
|
||||
{
|
||||
t_usize hash_id;
|
||||
|
|
@ -42,6 +51,13 @@ typedef struct s_entry_env
|
|||
struct s_entry_env *next;
|
||||
} t_entry_env;
|
||||
|
||||
/// @struct A hashmap of keys t_str and values t_str
|
||||
/// @var buckets The array of buckets
|
||||
/// @var num_buckets The number of buckets
|
||||
/// @var hasher The hasher function
|
||||
/// @var hfunc The hash function
|
||||
/// @var cfunc The comparison function
|
||||
/// @var drop The drop function
|
||||
typedef struct s_hashmap_env
|
||||
{
|
||||
t_entry_env **buckets;
|
||||
|
|
@ -52,31 +68,56 @@ typedef struct s_hashmap_env
|
|||
t_drop_env_fn drop;
|
||||
} t_hashmap_env;
|
||||
|
||||
t_hashmap_env *new_hashmap_env(t_hash_env_fn hash,
|
||||
t_eq_env_fn cmp,
|
||||
t_drop_env_fn drop);
|
||||
t_hashmap_env *new_hashmap_with_buckets_env(
|
||||
t_hash_env_fn hash, t_eq_env_fn cmp,
|
||||
t_drop_env_fn drop, size_t cap);
|
||||
/// @brief Creates a new hashmap with the given hash, comparison, and drop functions
|
||||
/// @param hash The hash function
|
||||
/// @param cmp The comparison function
|
||||
/// @param drop The drop function
|
||||
/// @return A new hashmap
|
||||
t_hashmap_env *hmap_new_env(t_hash_env_fn hash, t_eq_env_fn cmp, t_drop_env_fn drop);
|
||||
|
||||
void drop_hashmap_env(t_hashmap_env *hmap);
|
||||
/// @brief Creates a new hashmap with the given hash, comparison, and drop functions
|
||||
/// @param hash The hash function
|
||||
/// @param cmp The comparison function
|
||||
/// @param drop The drop function
|
||||
/// @param cap The number of buckets
|
||||
/// @return A new hashmap
|
||||
t_hashmap_env *hmap_new_with_buckets_env(t_hash_env_fn hash, t_eq_env_fn cmp, t_drop_env_fn drop, size_t cap);
|
||||
|
||||
void insert_hashmap_env(t_hashmap_env *hmap, t_str key,
|
||||
t_str value);
|
||||
/// @brief Drops the hashmap and all of its entries
|
||||
/// @param hmap The hashmap to drop
|
||||
void hmap_free_env(t_hashmap_env *hmap);
|
||||
|
||||
t_str *get_hashmap_env(t_hashmap_env *hmap,
|
||||
t_str *key);
|
||||
void remove_hashmap_env(t_hashmap_env *hmap, t_str *key);
|
||||
/// @brief Inserts a key-value pair into the hashmap
|
||||
/// @param hmap The hashmap
|
||||
/// @param key The key
|
||||
/// @param value The value
|
||||
void hmap_insert_env(t_hashmap_env *hmap, t_str key, t_str value);
|
||||
|
||||
t_entry_env *hashmap_get_entry_env(t_hashmap_env *hmap,
|
||||
t_usize hash,
|
||||
t_str *key,
|
||||
t_entry_env **prev);
|
||||
/// @brief Gets the value associated with the key
|
||||
/// @param hmap The hashmap
|
||||
/// @param key The key
|
||||
/// @return The value associated with the key, or NULL if the key is not in the hashmap
|
||||
t_str *hmap_get_env(t_hashmap_env *hmap, t_str *key);
|
||||
/// @brief Removes the key-value pair from the hashmap
|
||||
/// @param hmap The hashmap
|
||||
/// @param key The key
|
||||
void hmap_remove_env(t_hashmap_env *hmap, t_str *key);
|
||||
|
||||
t_error hashmap_env_iter(t_hashmap_env *self,
|
||||
t_error (*func)(t_usize idx,
|
||||
const t_str *key,
|
||||
t_str *val, void *ctx),
|
||||
void *ctx);
|
||||
/// @brief Get an entry from the hashmap
|
||||
/// @param hmap The hashmap
|
||||
/// @param hash The hash of the key
|
||||
/// @param key The key
|
||||
/// @param prev The previous entry in the bucket
|
||||
/// @return The entry, or NULL if the key is not in the hashmap
|
||||
/// @note this is an internal function
|
||||
t_entry_env *hmap_get_entry_env(t_hashmap_env *hmap, t_usize hash, t_str *key, t_entry_env **prev);
|
||||
|
||||
/// @brief Iterates over the hashmap and calls the given function for each key-value pair
|
||||
/// @param self The hashmap
|
||||
/// @param func The function to call
|
||||
/// @param ctx The context to pass to the function
|
||||
/// @return An error code
|
||||
/// @note The iteration can be stopped by returning an error code from the function
|
||||
t_error hmap_env_iter(t_hashmap_env *self, t_error (*func)(t_usize idx, const t_str *key, t_str *val, void *ctx), void *ctx);
|
||||
|
||||
#endif
|
||||
|
|
|
|||
|
|
@ -16,9 +16,12 @@
|
|||
#include "parser/types/types_heredoc.h"
|
||||
#include "me/types.h"
|
||||
|
||||
/// @brief A function that takes two t_heredoc and compare them
|
||||
typedef bool (*t_vec_parser_heredoc_sort_fn)(t_heredoc *, t_heredoc *);
|
||||
/// @brief A function that free an t_heredoc
|
||||
typedef void (*t_free_parser_heredoc_item)(t_heredoc);
|
||||
|
||||
/// @brief A dynamic array of t_heredoc
|
||||
typedef struct s_vec_parser_heredoc
|
||||
{
|
||||
t_free_parser_heredoc_item free_func;
|
||||
|
|
@ -27,32 +30,94 @@ typedef struct s_vec_parser_heredoc
|
|||
t_heredoc *buffer;
|
||||
} t_vec_parser_heredoc;
|
||||
|
||||
t_vec_parser_heredoc vec_parser_heredoc_new(t_usize capacity,
|
||||
t_free_parser_heredoc_item free_function);
|
||||
/// @brief Create a new vec_parser_heredoc with a given capacity
|
||||
/// @param capacity The capacity of the new vec_parser_heredoc (in terms of elements)
|
||||
/// @param free_function The function that will be used to free the elements of the vec_parser_heredoc
|
||||
t_vec_parser_heredoc vec_parser_heredoc_new(t_usize capacity, t_free_parser_heredoc_item free_function);
|
||||
/// @brief Push an element to the last position of the vec_parser_heredoc
|
||||
/// @param vec The vec_parser_heredoc to push the element to
|
||||
/// @param element The element to push
|
||||
t_error vec_parser_heredoc_push(t_vec_parser_heredoc *vec, t_heredoc element);
|
||||
t_error vec_parser_heredoc_push_front(t_vec_parser_heredoc *vec,
|
||||
t_heredoc element);
|
||||
|
||||
/// @brief Push an element to the first position of the vec_parser_heredoc
|
||||
/// @param vec The vec_parser_heredoc to push the element to
|
||||
/// @param element The element to push
|
||||
/// @note This operation is O(n)
|
||||
t_error vec_parser_heredoc_push_front(t_vec_parser_heredoc *vec, t_heredoc element);
|
||||
|
||||
/// @brief Get the last element from the vec_parser_heredoc, and remove it from the vec_parser_heredoc
|
||||
/// @param vec The vec_parser_heredoc to get the element from
|
||||
/// @param[out] out The last element of the vec_parser_heredoc
|
||||
/// @return true if the operation failed, false otherwise
|
||||
t_error vec_parser_heredoc_pop(t_vec_parser_heredoc *vec, t_heredoc *value);
|
||||
|
||||
|
||||
/// @brief Get the first element from the vec_parser_heredoc, and remove it from the vec_parser_heredoc
|
||||
/// @param vec The vec_parser_heredoc to get the element from
|
||||
/// @param[out] out The first element of the vec_parser_heredoc
|
||||
/// @return true if the operation failed, false otherwise
|
||||
/// @note This operation is O(n)
|
||||
t_error vec_parser_heredoc_pop_front(t_vec_parser_heredoc *vec, t_heredoc *value);
|
||||
|
||||
/// @brief Free the vector and all its elements
|
||||
/// @param vec The vec_parser_heredoc to free
|
||||
void vec_parser_heredoc_free(t_vec_parser_heredoc vec);
|
||||
t_error vec_parser_heredoc_reserve(t_vec_parser_heredoc *vec,
|
||||
t_usize wanted_capacity);
|
||||
t_error vec_parser_heredoc_find(t_vec_parser_heredoc *vec,
|
||||
bool (*fn)(const t_heredoc *), t_usize *index);
|
||||
t_error vec_parser_heredoc_find_starting(t_vec_parser_heredoc *vec,
|
||||
bool (*fn)(const t_heredoc *),
|
||||
t_usize starting_index, t_usize *index);
|
||||
t_error vec_parser_heredoc_all(t_vec_parser_heredoc *vec,
|
||||
bool (*fn)(const t_heredoc *), bool *result);
|
||||
t_error vec_parser_heredoc_any(t_vec_parser_heredoc *vec,
|
||||
bool (*fn)(const t_heredoc *), bool *result);
|
||||
void vec_parser_heredoc_iter(t_vec_parser_heredoc *vec,
|
||||
void (*fn)(t_usize index, t_heredoc *value,
|
||||
void *state),
|
||||
void *state);
|
||||
|
||||
/// @brief Make the vec_parser_heredoc at least the given capacity
|
||||
/// @param vec The vec_parser_heredoc to reserve
|
||||
/// @param wanted_capacity The minimum capacity to reserve
|
||||
/// @return true if the operation failed, false otherwise
|
||||
t_error vec_parser_heredoc_reserve(t_vec_parser_heredoc *vec, t_usize wanted_capacity);
|
||||
|
||||
/// @brief Run the function and returns the index of the first element that returns true
|
||||
/// @param vec The vec_parser_heredoc to search in
|
||||
/// @param fn The function to run on each element
|
||||
/// @param[out] index The index of the first element that returns true
|
||||
t_error vec_parser_heredoc_find(t_vec_parser_heredoc *vec, bool (*fn)(const t_heredoc *), t_usize *index);
|
||||
|
||||
|
||||
/// @brief Run the function and returns the index of the first element that returns true, but starting at index starting_index
|
||||
/// @param vec The vec_parser_heredoc to search in
|
||||
/// @param fn The function to run on each element
|
||||
/// @param starting_index The index to start the search from
|
||||
/// @param[out] index The index of the first element that returns true
|
||||
t_error vec_parser_heredoc_find_starting(t_vec_parser_heredoc *vec, bool (*fn)(const t_heredoc *), t_usize starting_index, t_usize *index);
|
||||
|
||||
/// @brief Run the function on every element of the vec_parser_heredoc and returns if all elements returned true
|
||||
/// @param vec The vec_parser_heredoc to search in
|
||||
/// @param fn The function to run on each element
|
||||
/// @param[out] result The result of the operation
|
||||
/// @return true if the operation failed, false otherwise
|
||||
/// @note If the vec_parser_heredoc is empty, result will be true
|
||||
t_error vec_parser_heredoc_all(t_vec_parser_heredoc *vec, bool (*fn)(const t_heredoc *), bool *result);
|
||||
|
||||
/// @brief Run the function on every element of the vec_parser_heredoc and returns if any element returned true
|
||||
/// @param vec The vec_parser_heredoc to search in
|
||||
/// @param fn The function to run on each element
|
||||
/// @param[out] result The result of the operation
|
||||
/// @return true if the operation failed, false otherwise
|
||||
/// @note If the vec_parser_heredoc is empty, result will be false
|
||||
t_error vec_parser_heredoc_any(t_vec_parser_heredoc *vec, bool (*fn)(const t_heredoc *), bool *result);
|
||||
|
||||
/// @brief Run the function on every element of the vec_parser_heredoc
|
||||
/// @param vec The vec_parser_heredoc to iterate over
|
||||
/// @param fn The function to run on each element
|
||||
/// @param state The state to pass to the function
|
||||
void vec_parser_heredoc_iter(t_vec_parser_heredoc *vec, void (*fn)(t_usize index, t_heredoc *value, void *state), void *state);
|
||||
|
||||
/// @brief Reverse the order of the elements in the vec_parser_heredoc
|
||||
/// @param vec The vec_parser_heredoc to reverse
|
||||
void vec_parser_heredoc_reverse(t_vec_parser_heredoc *vec);
|
||||
void vec_parser_heredoc_sort(t_vec_parser_heredoc *vec,
|
||||
t_vec_parser_heredoc_sort_fn is_sorted);
|
||||
|
||||
/// @brief Sort the elements of the vec_parser_heredoc
|
||||
/// @param vec The vec_parser_heredoc to sort
|
||||
/// @param is_sorted The function to use to compare the elements
|
||||
void vec_parser_heredoc_sort(t_vec_parser_heredoc *vec, t_vec_parser_heredoc_sort_fn is_sorted);
|
||||
|
||||
/// @brief Get a pointer to the last element of the vec_parser_heredoc
|
||||
/// @param vec The vec_parser_heredoc to get the element from
|
||||
/// @param[out] out A pointer to the last element of the vec_parser_heredoc
|
||||
/// @return true if the operation failed, false otherwise
|
||||
t_error vec_parser_heredoc_back(t_vec_parser_heredoc *vec, t_heredoc **out);
|
||||
|
||||
#endif
|
||||
|
|
|
|||
|
|
@ -16,9 +16,12 @@
|
|||
#include "parser/types/types_parser_range.h"
|
||||
#include "me/types.h"
|
||||
|
||||
/// @brief A function that takes two t_parser_range and compare them
|
||||
typedef bool (*t_vec_parser_range_sort_fn)(t_parser_range *, t_parser_range *);
|
||||
/// @brief A function that free an t_parser_range
|
||||
typedef void (*t_free_parser_range_item)(t_parser_range);
|
||||
|
||||
/// @brief A dynamic array of t_parser_range
|
||||
typedef struct s_vec_parser_range
|
||||
{
|
||||
t_free_parser_range_item free_func;
|
||||
|
|
@ -27,32 +30,94 @@ typedef struct s_vec_parser_range
|
|||
t_parser_range *buffer;
|
||||
} t_vec_parser_range;
|
||||
|
||||
t_vec_parser_range vec_parser_range_new(t_usize capacity,
|
||||
t_free_parser_range_item free_function);
|
||||
/// @brief Create a new vec_parser_range with a given capacity
|
||||
/// @param capacity The capacity of the new vec_parser_range (in terms of elements)
|
||||
/// @param free_function The function that will be used to free the elements of the vec_parser_range
|
||||
t_vec_parser_range vec_parser_range_new(t_usize capacity, t_free_parser_range_item free_function);
|
||||
/// @brief Push an element to the last position of the vec_parser_range
|
||||
/// @param vec The vec_parser_range to push the element to
|
||||
/// @param element The element to push
|
||||
t_error vec_parser_range_push(t_vec_parser_range *vec, t_parser_range element);
|
||||
t_error vec_parser_range_push_front(t_vec_parser_range *vec,
|
||||
t_parser_range element);
|
||||
|
||||
/// @brief Push an element to the first position of the vec_parser_range
|
||||
/// @param vec The vec_parser_range to push the element to
|
||||
/// @param element The element to push
|
||||
/// @note This operation is O(n)
|
||||
t_error vec_parser_range_push_front(t_vec_parser_range *vec, t_parser_range element);
|
||||
|
||||
/// @brief Get the last element from the vec_parser_range, and remove it from the vec_parser_range
|
||||
/// @param vec The vec_parser_range to get the element from
|
||||
/// @param[out] out The last element of the vec_parser_range
|
||||
/// @return true if the operation failed, false otherwise
|
||||
t_error vec_parser_range_pop(t_vec_parser_range *vec, t_parser_range *value);
|
||||
|
||||
|
||||
/// @brief Get the first element from the vec_parser_range, and remove it from the vec_parser_range
|
||||
/// @param vec The vec_parser_range to get the element from
|
||||
/// @param[out] out The first element of the vec_parser_range
|
||||
/// @return true if the operation failed, false otherwise
|
||||
/// @note This operation is O(n)
|
||||
t_error vec_parser_range_pop_front(t_vec_parser_range *vec, t_parser_range *value);
|
||||
|
||||
/// @brief Free the vector and all its elements
|
||||
/// @param vec The vec_parser_range to free
|
||||
void vec_parser_range_free(t_vec_parser_range vec);
|
||||
t_error vec_parser_range_reserve(t_vec_parser_range *vec,
|
||||
t_usize wanted_capacity);
|
||||
t_error vec_parser_range_find(t_vec_parser_range *vec,
|
||||
bool (*fn)(const t_parser_range *), t_usize *index);
|
||||
t_error vec_parser_range_find_starting(t_vec_parser_range *vec,
|
||||
bool (*fn)(const t_parser_range *),
|
||||
t_usize starting_index, t_usize *index);
|
||||
t_error vec_parser_range_all(t_vec_parser_range *vec,
|
||||
bool (*fn)(const t_parser_range *), bool *result);
|
||||
t_error vec_parser_range_any(t_vec_parser_range *vec,
|
||||
bool (*fn)(const t_parser_range *), bool *result);
|
||||
void vec_parser_range_iter(t_vec_parser_range *vec,
|
||||
void (*fn)(t_usize index, t_parser_range *value,
|
||||
void *state),
|
||||
void *state);
|
||||
|
||||
/// @brief Make the vec_parser_range at least the given capacity
|
||||
/// @param vec The vec_parser_range to reserve
|
||||
/// @param wanted_capacity The minimum capacity to reserve
|
||||
/// @return true if the operation failed, false otherwise
|
||||
t_error vec_parser_range_reserve(t_vec_parser_range *vec, t_usize wanted_capacity);
|
||||
|
||||
/// @brief Run the function and returns the index of the first element that returns true
|
||||
/// @param vec The vec_parser_range to search in
|
||||
/// @param fn The function to run on each element
|
||||
/// @param[out] index The index of the first element that returns true
|
||||
t_error vec_parser_range_find(t_vec_parser_range *vec, bool (*fn)(const t_parser_range *), t_usize *index);
|
||||
|
||||
|
||||
/// @brief Run the function and returns the index of the first element that returns true, but starting at index starting_index
|
||||
/// @param vec The vec_parser_range to search in
|
||||
/// @param fn The function to run on each element
|
||||
/// @param starting_index The index to start the search from
|
||||
/// @param[out] index The index of the first element that returns true
|
||||
t_error vec_parser_range_find_starting(t_vec_parser_range *vec, bool (*fn)(const t_parser_range *), t_usize starting_index, t_usize *index);
|
||||
|
||||
/// @brief Run the function on every element of the vec_parser_range and returns if all elements returned true
|
||||
/// @param vec The vec_parser_range to search in
|
||||
/// @param fn The function to run on each element
|
||||
/// @param[out] result The result of the operation
|
||||
/// @return true if the operation failed, false otherwise
|
||||
/// @note If the vec_parser_range is empty, result will be true
|
||||
t_error vec_parser_range_all(t_vec_parser_range *vec, bool (*fn)(const t_parser_range *), bool *result);
|
||||
|
||||
/// @brief Run the function on every element of the vec_parser_range and returns if any element returned true
|
||||
/// @param vec The vec_parser_range to search in
|
||||
/// @param fn The function to run on each element
|
||||
/// @param[out] result The result of the operation
|
||||
/// @return true if the operation failed, false otherwise
|
||||
/// @note If the vec_parser_range is empty, result will be false
|
||||
t_error vec_parser_range_any(t_vec_parser_range *vec, bool (*fn)(const t_parser_range *), bool *result);
|
||||
|
||||
/// @brief Run the function on every element of the vec_parser_range
|
||||
/// @param vec The vec_parser_range to iterate over
|
||||
/// @param fn The function to run on each element
|
||||
/// @param state The state to pass to the function
|
||||
void vec_parser_range_iter(t_vec_parser_range *vec, void (*fn)(t_usize index, t_parser_range *value, void *state), void *state);
|
||||
|
||||
/// @brief Reverse the order of the elements in the vec_parser_range
|
||||
/// @param vec The vec_parser_range to reverse
|
||||
void vec_parser_range_reverse(t_vec_parser_range *vec);
|
||||
void vec_parser_range_sort(t_vec_parser_range *vec,
|
||||
t_vec_parser_range_sort_fn is_sorted);
|
||||
|
||||
/// @brief Sort the elements of the vec_parser_range
|
||||
/// @param vec The vec_parser_range to sort
|
||||
/// @param is_sorted The function to use to compare the elements
|
||||
void vec_parser_range_sort(t_vec_parser_range *vec, t_vec_parser_range_sort_fn is_sorted);
|
||||
|
||||
/// @brief Get a pointer to the last element of the vec_parser_range
|
||||
/// @param vec The vec_parser_range to get the element from
|
||||
/// @param[out] out A pointer to the last element of the vec_parser_range
|
||||
/// @return true if the operation failed, false otherwise
|
||||
t_error vec_parser_range_back(t_vec_parser_range *vec, t_parser_range **out);
|
||||
|
||||
#endif
|
||||
|
|
|
|||
|
|
@ -16,9 +16,12 @@
|
|||
#include "parser/types/types_reduce_action.h"
|
||||
#include "me/types.h"
|
||||
|
||||
/// @brief A function that takes two t_reduce_action and compare them
|
||||
typedef bool (*t_vec_reduce_action_sort_fn)(t_reduce_action *, t_reduce_action *);
|
||||
/// @brief A function that free an t_reduce_action
|
||||
typedef void (*t_free_reduce_action_item)(t_reduce_action);
|
||||
|
||||
/// @brief A dynamic array of t_reduce_action
|
||||
typedef struct s_vec_reduce_action
|
||||
{
|
||||
t_free_reduce_action_item free_func;
|
||||
|
|
@ -27,32 +30,94 @@ typedef struct s_vec_reduce_action
|
|||
t_reduce_action *buffer;
|
||||
} t_vec_reduce_action;
|
||||
|
||||
t_vec_reduce_action vec_reduce_action_new(t_usize capacity,
|
||||
t_free_reduce_action_item free_function);
|
||||
/// @brief Create a new vec_reduce_action with a given capacity
|
||||
/// @param capacity The capacity of the new vec_reduce_action (in terms of elements)
|
||||
/// @param free_function The function that will be used to free the elements of the vec_reduce_action
|
||||
t_vec_reduce_action vec_reduce_action_new(t_usize capacity, t_free_reduce_action_item free_function);
|
||||
/// @brief Push an element to the last position of the vec_reduce_action
|
||||
/// @param vec The vec_reduce_action to push the element to
|
||||
/// @param element The element to push
|
||||
t_error vec_reduce_action_push(t_vec_reduce_action *vec, t_reduce_action element);
|
||||
t_error vec_reduce_action_push_front(t_vec_reduce_action *vec,
|
||||
t_reduce_action element);
|
||||
|
||||
/// @brief Push an element to the first position of the vec_reduce_action
|
||||
/// @param vec The vec_reduce_action to push the element to
|
||||
/// @param element The element to push
|
||||
/// @note This operation is O(n)
|
||||
t_error vec_reduce_action_push_front(t_vec_reduce_action *vec, t_reduce_action element);
|
||||
|
||||
/// @brief Get the last element from the vec_reduce_action, and remove it from the vec_reduce_action
|
||||
/// @param vec The vec_reduce_action to get the element from
|
||||
/// @param[out] out The last element of the vec_reduce_action
|
||||
/// @return true if the operation failed, false otherwise
|
||||
t_error vec_reduce_action_pop(t_vec_reduce_action *vec, t_reduce_action *value);
|
||||
|
||||
|
||||
/// @brief Get the first element from the vec_reduce_action, and remove it from the vec_reduce_action
|
||||
/// @param vec The vec_reduce_action to get the element from
|
||||
/// @param[out] out The first element of the vec_reduce_action
|
||||
/// @return true if the operation failed, false otherwise
|
||||
/// @note This operation is O(n)
|
||||
t_error vec_reduce_action_pop_front(t_vec_reduce_action *vec, t_reduce_action *value);
|
||||
|
||||
/// @brief Free the vector and all its elements
|
||||
/// @param vec The vec_reduce_action to free
|
||||
void vec_reduce_action_free(t_vec_reduce_action vec);
|
||||
t_error vec_reduce_action_reserve(t_vec_reduce_action *vec,
|
||||
t_usize wanted_capacity);
|
||||
t_error vec_reduce_action_find(t_vec_reduce_action *vec,
|
||||
bool (*fn)(const t_reduce_action *), t_usize *index);
|
||||
t_error vec_reduce_action_find_starting(t_vec_reduce_action *vec,
|
||||
bool (*fn)(const t_reduce_action *),
|
||||
t_usize starting_index, t_usize *index);
|
||||
t_error vec_reduce_action_all(t_vec_reduce_action *vec,
|
||||
bool (*fn)(const t_reduce_action *), bool *result);
|
||||
t_error vec_reduce_action_any(t_vec_reduce_action *vec,
|
||||
bool (*fn)(const t_reduce_action *), bool *result);
|
||||
void vec_reduce_action_iter(t_vec_reduce_action *vec,
|
||||
void (*fn)(t_usize index, t_reduce_action *value,
|
||||
void *state),
|
||||
void *state);
|
||||
|
||||
/// @brief Make the vec_reduce_action at least the given capacity
|
||||
/// @param vec The vec_reduce_action to reserve
|
||||
/// @param wanted_capacity The minimum capacity to reserve
|
||||
/// @return true if the operation failed, false otherwise
|
||||
t_error vec_reduce_action_reserve(t_vec_reduce_action *vec, t_usize wanted_capacity);
|
||||
|
||||
/// @brief Run the function and returns the index of the first element that returns true
|
||||
/// @param vec The vec_reduce_action to search in
|
||||
/// @param fn The function to run on each element
|
||||
/// @param[out] index The index of the first element that returns true
|
||||
t_error vec_reduce_action_find(t_vec_reduce_action *vec, bool (*fn)(const t_reduce_action *), t_usize *index);
|
||||
|
||||
|
||||
/// @brief Run the function and returns the index of the first element that returns true, but starting at index starting_index
|
||||
/// @param vec The vec_reduce_action to search in
|
||||
/// @param fn The function to run on each element
|
||||
/// @param starting_index The index to start the search from
|
||||
/// @param[out] index The index of the first element that returns true
|
||||
t_error vec_reduce_action_find_starting(t_vec_reduce_action *vec, bool (*fn)(const t_reduce_action *), t_usize starting_index, t_usize *index);
|
||||
|
||||
/// @brief Run the function on every element of the vec_reduce_action and returns if all elements returned true
|
||||
/// @param vec The vec_reduce_action to search in
|
||||
/// @param fn The function to run on each element
|
||||
/// @param[out] result The result of the operation
|
||||
/// @return true if the operation failed, false otherwise
|
||||
/// @note If the vec_reduce_action is empty, result will be true
|
||||
t_error vec_reduce_action_all(t_vec_reduce_action *vec, bool (*fn)(const t_reduce_action *), bool *result);
|
||||
|
||||
/// @brief Run the function on every element of the vec_reduce_action and returns if any element returned true
|
||||
/// @param vec The vec_reduce_action to search in
|
||||
/// @param fn The function to run on each element
|
||||
/// @param[out] result The result of the operation
|
||||
/// @return true if the operation failed, false otherwise
|
||||
/// @note If the vec_reduce_action is empty, result will be false
|
||||
t_error vec_reduce_action_any(t_vec_reduce_action *vec, bool (*fn)(const t_reduce_action *), bool *result);
|
||||
|
||||
/// @brief Run the function on every element of the vec_reduce_action
|
||||
/// @param vec The vec_reduce_action to iterate over
|
||||
/// @param fn The function to run on each element
|
||||
/// @param state The state to pass to the function
|
||||
void vec_reduce_action_iter(t_vec_reduce_action *vec, void (*fn)(t_usize index, t_reduce_action *value, void *state), void *state);
|
||||
|
||||
/// @brief Reverse the order of the elements in the vec_reduce_action
|
||||
/// @param vec The vec_reduce_action to reverse
|
||||
void vec_reduce_action_reverse(t_vec_reduce_action *vec);
|
||||
void vec_reduce_action_sort(t_vec_reduce_action *vec,
|
||||
t_vec_reduce_action_sort_fn is_sorted);
|
||||
|
||||
/// @brief Sort the elements of the vec_reduce_action
|
||||
/// @param vec The vec_reduce_action to sort
|
||||
/// @param is_sorted The function to use to compare the elements
|
||||
void vec_reduce_action_sort(t_vec_reduce_action *vec, t_vec_reduce_action_sort_fn is_sorted);
|
||||
|
||||
/// @brief Get a pointer to the last element of the vec_reduce_action
|
||||
/// @param vec The vec_reduce_action to get the element from
|
||||
/// @param[out] out A pointer to the last element of the vec_reduce_action
|
||||
/// @return true if the operation failed, false otherwise
|
||||
t_error vec_reduce_action_back(t_vec_reduce_action *vec, t_reduce_action **out);
|
||||
|
||||
#endif
|
||||
|
|
|
|||
|
|
@ -16,9 +16,12 @@
|
|||
|
||||
#include "me/types.h"
|
||||
|
||||
/// @brief A function that takes two t_str and compare them
|
||||
typedef bool (*t_vec_str_sort_fn)(t_str *, t_str *);
|
||||
/// @brief A function that free an t_str
|
||||
typedef void (*t_free_str_item)(t_str);
|
||||
|
||||
/// @brief A dynamic array of t_str
|
||||
typedef struct s_vec_str
|
||||
{
|
||||
t_free_str_item free_func;
|
||||
|
|
@ -27,32 +30,94 @@ typedef struct s_vec_str
|
|||
t_str *buffer;
|
||||
} t_vec_str;
|
||||
|
||||
t_vec_str vec_str_new(t_usize capacity,
|
||||
t_free_str_item free_function);
|
||||
/// @brief Create a new vec_str with a given capacity
|
||||
/// @param capacity The capacity of the new vec_str (in terms of elements)
|
||||
/// @param free_function The function that will be used to free the elements of the vec_str
|
||||
t_vec_str vec_str_new(t_usize capacity, t_free_str_item free_function);
|
||||
/// @brief Push an element to the last position of the vec_str
|
||||
/// @param vec The vec_str to push the element to
|
||||
/// @param element The element to push
|
||||
t_error vec_str_push(t_vec_str *vec, t_str element);
|
||||
t_error vec_str_push_front(t_vec_str *vec,
|
||||
t_str element);
|
||||
|
||||
/// @brief Push an element to the first position of the vec_str
|
||||
/// @param vec The vec_str to push the element to
|
||||
/// @param element The element to push
|
||||
/// @note This operation is O(n)
|
||||
t_error vec_str_push_front(t_vec_str *vec, t_str element);
|
||||
|
||||
/// @brief Get the last element from the vec_str, and remove it from the vec_str
|
||||
/// @param vec The vec_str to get the element from
|
||||
/// @param[out] out The last element of the vec_str
|
||||
/// @return true if the operation failed, false otherwise
|
||||
t_error vec_str_pop(t_vec_str *vec, t_str *value);
|
||||
|
||||
|
||||
/// @brief Get the first element from the vec_str, and remove it from the vec_str
|
||||
/// @param vec The vec_str to get the element from
|
||||
/// @param[out] out The first element of the vec_str
|
||||
/// @return true if the operation failed, false otherwise
|
||||
/// @note This operation is O(n)
|
||||
t_error vec_str_pop_front(t_vec_str *vec, t_str *value);
|
||||
|
||||
/// @brief Free the vector and all its elements
|
||||
/// @param vec The vec_str to free
|
||||
void vec_str_free(t_vec_str vec);
|
||||
t_error vec_str_reserve(t_vec_str *vec,
|
||||
t_usize wanted_capacity);
|
||||
t_error vec_str_find(t_vec_str *vec,
|
||||
bool (*fn)(const t_str *), t_usize *index);
|
||||
t_error vec_str_find_starting(t_vec_str *vec,
|
||||
bool (*fn)(const t_str *),
|
||||
t_usize starting_index, t_usize *index);
|
||||
t_error vec_str_all(t_vec_str *vec,
|
||||
bool (*fn)(const t_str *), bool *result);
|
||||
t_error vec_str_any(t_vec_str *vec,
|
||||
bool (*fn)(const t_str *), bool *result);
|
||||
void vec_str_iter(t_vec_str *vec,
|
||||
void (*fn)(t_usize index, t_str *value,
|
||||
void *state),
|
||||
void *state);
|
||||
|
||||
/// @brief Make the vec_str at least the given capacity
|
||||
/// @param vec The vec_str to reserve
|
||||
/// @param wanted_capacity The minimum capacity to reserve
|
||||
/// @return true if the operation failed, false otherwise
|
||||
t_error vec_str_reserve(t_vec_str *vec, t_usize wanted_capacity);
|
||||
|
||||
/// @brief Run the function and returns the index of the first element that returns true
|
||||
/// @param vec The vec_str to search in
|
||||
/// @param fn The function to run on each element
|
||||
/// @param[out] index The index of the first element that returns true
|
||||
t_error vec_str_find(t_vec_str *vec, bool (*fn)(const t_str *), t_usize *index);
|
||||
|
||||
|
||||
/// @brief Run the function and returns the index of the first element that returns true, but starting at index starting_index
|
||||
/// @param vec The vec_str to search in
|
||||
/// @param fn The function to run on each element
|
||||
/// @param starting_index The index to start the search from
|
||||
/// @param[out] index The index of the first element that returns true
|
||||
t_error vec_str_find_starting(t_vec_str *vec, bool (*fn)(const t_str *), t_usize starting_index, t_usize *index);
|
||||
|
||||
/// @brief Run the function on every element of the vec_str and returns if all elements returned true
|
||||
/// @param vec The vec_str to search in
|
||||
/// @param fn The function to run on each element
|
||||
/// @param[out] result The result of the operation
|
||||
/// @return true if the operation failed, false otherwise
|
||||
/// @note If the vec_str is empty, result will be true
|
||||
t_error vec_str_all(t_vec_str *vec, bool (*fn)(const t_str *), bool *result);
|
||||
|
||||
/// @brief Run the function on every element of the vec_str and returns if any element returned true
|
||||
/// @param vec The vec_str to search in
|
||||
/// @param fn The function to run on each element
|
||||
/// @param[out] result The result of the operation
|
||||
/// @return true if the operation failed, false otherwise
|
||||
/// @note If the vec_str is empty, result will be false
|
||||
t_error vec_str_any(t_vec_str *vec, bool (*fn)(const t_str *), bool *result);
|
||||
|
||||
/// @brief Run the function on every element of the vec_str
|
||||
/// @param vec The vec_str to iterate over
|
||||
/// @param fn The function to run on each element
|
||||
/// @param state The state to pass to the function
|
||||
void vec_str_iter(t_vec_str *vec, void (*fn)(t_usize index, t_str *value, void *state), void *state);
|
||||
|
||||
/// @brief Reverse the order of the elements in the vec_str
|
||||
/// @param vec The vec_str to reverse
|
||||
void vec_str_reverse(t_vec_str *vec);
|
||||
void vec_str_sort(t_vec_str *vec,
|
||||
t_vec_str_sort_fn is_sorted);
|
||||
|
||||
/// @brief Sort the elements of the vec_str
|
||||
/// @param vec The vec_str to sort
|
||||
/// @param is_sorted The function to use to compare the elements
|
||||
void vec_str_sort(t_vec_str *vec, t_vec_str_sort_fn is_sorted);
|
||||
|
||||
/// @brief Get a pointer to the last element of the vec_str
|
||||
/// @param vec The vec_str to get the element from
|
||||
/// @param[out] out A pointer to the last element of the vec_str
|
||||
/// @return true if the operation failed, false otherwise
|
||||
t_error vec_str_back(t_vec_str *vec, t_str **out);
|
||||
|
||||
#endif
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue