feat: add mathematics_max, mathematics_min

Also add `mathematics_max_values` and `mathematics_min_values` to check in array.
feat: add mathematics_opposite
2025-05-21 23:21:15 +02:00 · 2024-09-13 15:35:19 +02:00 · 2024-09-13 14:44:26 +02:00 · 2024-09-12 12:31:58 +02:00 · 2024-09-12 12:22:53 +02:00 · 2024-01-30 01:25:17 +01:00
63 changed files with 2244 additions and 674 deletions
--- a/.clang-format
+++ b/.clang-format
@ -1,2 +1,2 @@
-BasedOnStyle: 'Google'
+BasedOnStyle: "Google"
 ColumnLimit: 0
--- a/.github/ISSUE_TEMPLATE/BUG.md
+++ b/.github/ISSUE_TEMPLATE/BUG.md
@ -1,8 +1,8 @@
 ---
-name: '🐛 Bug Report'
-about: 'Report an unexpected problem or unintended behavior.'
-title: '[Bug]'
-labels: 'bug'
+name: "🐛 Bug Report"
+about: "Report an unexpected problem or unintended behavior."
+title: "[Bug]"
+labels: "bug"
 ---

 <!--
--- a/.github/ISSUE_TEMPLATE/DOCUMENTATION.md
+++ b/.github/ISSUE_TEMPLATE/DOCUMENTATION.md
@ -1,8 +1,8 @@
 ---
-name: '📜 Documentation'
-about: 'Correct spelling errors, improvements or additions to documentation files (README, CONTRIBUTING...).'
-title: '[Documentation]'
-labels: 'documentation'
+name: "📜 Documentation"
+about: "Correct spelling errors, improvements or additions to documentation files (README, CONTRIBUTING...)."
+title: "[Documentation]"
+labels: "documentation"
 ---

 <!-- Please make sure your issue has not already been fixed. -->
--- a/.github/ISSUE_TEMPLATE/FEATURE_REQUEST.md
+++ b/.github/ISSUE_TEMPLATE/FEATURE_REQUEST.md
@ -1,8 +1,8 @@
 ---
-name: '✨ Feature Request'
-about: 'Suggest a new feature idea.'
-title: '[Feature]'
-labels: 'feature request'
+name: "✨ Feature Request"
+about: "Suggest a new feature idea."
+title: "[Feature]"
+labels: "feature request"
 ---

 <!-- Please make sure your issue has not already been fixed. -->
--- a/.github/ISSUE_TEMPLATE/IMPROVEMENT.md
+++ b/.github/ISSUE_TEMPLATE/IMPROVEMENT.md
@ -1,8 +1,8 @@
 ---
-name: '🔧 Improvement'
-about: 'Improve structure/format/performance/refactor/tests of the code.'
-title: '[Improvement]'
-labels: 'improvement'
+name: "🔧 Improvement"
+about: "Improve structure/format/performance/refactor/tests of the code."
+title: "[Improvement]"
+labels: "improvement"
 ---

 <!-- Please make sure your issue has not already been fixed. -->
--- a/.github/ISSUE_TEMPLATE/QUESTION.md
+++ b/.github/ISSUE_TEMPLATE/QUESTION.md
@ -1,8 +1,8 @@
 ---
-name: '🙋 Question'
-about: 'Further information is requested.'
-title: '[Question]'
-labels: 'question'
+name: "🙋 Question"
+about: "Further information is requested."
+title: "[Question]"
+labels: "question"
 ---

 ### Question
--- a/.github/PULL_REQUEST_TEMPLATE.md
+++ b/.github/PULL_REQUEST_TEMPLATE.md
@ -1,6 +1,6 @@
 <!-- Please first discuss the change you wish to make via issue before making a change. It might avoid a waste of your time. -->

-## What changes this PR introduce?
+# What changes this PR introduce?

 ## List any relevant issue numbers

--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@ -1,4 +1,4 @@
-name: 'CI'
+name: "CI"

 on:
  push:
@ -8,24 +8,33 @@ on:

 jobs:
  ci:
-    runs-on: 'ubuntu-latest'
+    runs-on: "ubuntu-latest"
    steps:
-      - uses: 'actions/checkout@v3.0.0'
+      - uses: "actions/checkout@v4.1.1"

-      - name: 'Install Build Tools'
-        run: 'sudo apt-get install --yes build-essential gcc make clang-format'
+      - run: "sudo apt update"

-      - run: 'make'
-      - run: 'make run'
-      - run: 'make test'
-      - run: 'make lint'
-      - run: 'make clean'
+      - name: "Install Build Tools"
+        run: "sudo apt install --yes build-essential gcc make clang-format"
+
+      - name: "Install Documentation Tools"
+        run: "sudo apt install --yes doxygen doxygen-gui doxygen-doc graphviz"
+
+      - run: "gcc --version"
+
+      - run: "make"
+      - run: "make run"
+      - run: "make test"
+      - run: "make lint"
+      - run: "make documentation"
+      - run: "make set_version"
+      - run: "make clean"

  lint-commit:
-      runs-on: 'ubuntu-latest'
-      steps:
-        - uses: 'actions/checkout@v3.0.0'
-          with:
-            fetch-depth: 0
+    runs-on: "ubuntu-latest"
+    steps:
+      - uses: "actions/checkout@v4.1.1"
+        with:
+          fetch-depth: 0

-        - uses: 'wagoid/commitlint-github-action@v5.3.0'
+      - uses: "wagoid/commitlint-github-action@v5.4.4"
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@ -1,4 +1,4 @@
-name: 'Release'
+name: "Release"

 on:
  push:
@ -6,47 +6,52 @@ on:

 jobs:
  release:
-    runs-on: 'ubuntu-latest'
+    runs-on: "ubuntu-latest"
    steps:
-      - uses: 'actions/checkout@v3.1.0'
+      - uses: "actions/checkout@v4.1.1"
        with:
          fetch-depth: 0
          persist-credentials: false
-          submodules: recursive
+          submodules: "recursive"

-      - name: 'Import GPG key'
-        uses: 'crazy-max/ghaction-import-gpg@v4'
+      - name: "Import GPG key"
+        uses: "crazy-max/ghaction-import-gpg@v6.1.0"
        with:
          gpg_private_key: ${{ secrets.GPG_PRIVATE_KEY }}
          git_user_signingkey: true
          git_commit_gpgsign: true

-      - name: 'Install Build Tools'
-        run: 'sudo apt-get install --yes build-essential gcc make clang-format doxygen doxygen-gui doxygen-doc graphviz'
+      - run: "sudo apt update"

-      - run: 'make set_version'
+      - name: "Install Build Tools"
+        run: "sudo apt install --yes build-essential gcc make clang-format"

-      - name: 'Use Node.js'
-        uses: 'actions/setup-node@v3.1.0'
+      - name: "Install Documentation Tools"
+        run: "sudo apt install --yes doxygen doxygen-gui doxygen-doc graphviz"
+
+      - run: "make set_version"
+
+      - name: "Use Node.js"
+        uses: "actions/setup-node@v4.0.1"
        with:
-          node-version: 'lts/*'
+          node-version: "20.10.0"

-      - name: 'Install Release Tools'
-        run: 'npm install --save-dev semantic-release @commitlint/cli @commitlint/config-conventional @semantic-release/git @semantic-release/exec @saithodev/semantic-release-backmerge vercel'
+      - name: "Install Release Tools"
+        run: "npm install --save-dev semantic-release@22.0.12 @commitlint/cli@18.4.3 @commitlint/config-conventional@18.4.3 @semantic-release/git@10.0.1 @semantic-release/exec@6.0.3 @saithodev/semantic-release-backmerge@4.0.1 vercel@33.0.1"

-      - run: 'rm --force package.json package-lock.json'
+      - run: "rm --force package.json package-lock.json"

-      - name: 'Release'
-        run: 'npx semantic-release'
+      - name: "Release"
+        run: "npx semantic-release"
        env:
          GH_TOKEN: ${{ secrets.GH_TOKEN }}
          GIT_COMMITTER_NAME: ${{ secrets.GIT_NAME }}
          GIT_COMMITTER_EMAIL: ${{ secrets.GIT_EMAIL }}

-      - name: 'Generate Documentation'
-        run: 'make documentation'
+      - name: "Generate Documentation"
+        run: "make documentation"

-      - name: 'Deploy to Vercel'
+      - name: "Deploy to Vercel"
        run: 'npx vercel ./documentation/html --token="${VERCEL_TOKEN}" --prod'
        env:
          VERCEL_TOKEN: ${{ secrets.VERCEL_TOKEN }}
--- a/.gitignore
+++ b/.gitignore
@ -4,6 +4,7 @@ documentation
 .vscode
 *.out
 *.o
-*.exe
 *.a
 node_modules
+package.json
+package-lock.json
--- a/.releaserc.json
+++ b/.releaserc.json
@ -16,7 +16,7 @@
    [
      "@semantic-release/exec",
      {
-        "prepareCmd": "make set_version && ./bin/set_version.exe ${nextRelease.version}"
+        "prepareCmd": "make set_version && ./bin/set_version ${nextRelease.version}"
      }
    ],
    [
--- a/CODE_OF_CONDUCT.md
+++ b/CODE_OF_CONDUCT.md
@ -60,7 +60,7 @@ representative at an online or offline event.

 Instances of abusive, harassing, or otherwise unacceptable behavior may be
 reported to the community leaders responsible for enforcement at
-contact@divlo.fr.
+<contact@theoludwig.fr>.
 All complaints will be reviewed and investigated promptly and fairly.

 All community leaders are obligated to respect the privacy and security of the
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@ -2,6 +2,14 @@

 Thanks a lot for your interest in contributing to **libcproject**! 🎉

+## Code of Conduct
+
+**libcproject** adopted the [Contributor Covenant](https://www.contributor-covenant.org/) as its Code of Conduct, and we expect project participants to adhere to it. Please read [the full text](./CODE_OF_CONDUCT.md) so that you can understand what actions will and will not be tolerated.
+
+## Open Development
+
+All work on **libcproject** happens directly on this repository. Both core team members and external contributors send pull requests which go through the same review process.
+
 ## Types of contributions

 - Reporting a bug.
@ -11,7 +19,7 @@ Thanks a lot for your interest in contributing to **libcproject**! 🎉

 ## Pull Requests

- **Please first discuss** the change you wish to make via [issue](https://github.com/Divlo/libcproject/issues) before making a change. It might avoid a waste of your time.
+- **Please first discuss** the change you wish to make via [issue](https://github.com/theoludwig/libcproject/issues) before making a change. It might avoid a waste of your time.

 - Ensure your code respect linting.

@ -21,26 +29,4 @@ If you're adding new features to **libcproject**, please include tests.

 ## Commits

-The commit message guidelines respect [@commitlint/config-conventional](https://github.com/conventional-changelog/commitlint/tree/master/%40commitlint/config-conventional) and [Semantic Versioning](https://semver.org/) for releases.
-
-### Types
-
-Types define which kind of changes you made to the project.
-
-| Types    | Description                                                                                                  |
-| -------- | ------------------------------------------------------------------------------------------------------------ |
-| feat     | A new feature.                                                                                               |
-| fix      | A bug fix.                                                                                                   |
-| docs     | Documentation only changes.                                                                                  |
-| style    | Changes that do not affect the meaning of the code (white-space, formatting, missing semi-colons, etc).      |
-| refactor | A code change that neither fixes a bug nor adds a feature.                                                   |
-| perf     | A code change that improves performance.                                                                     |
-| test     | Adding missing tests or correcting existing tests.                                                           |
-| build    | Changes that affect the build system or external dependencies (example scopes: gulp, broccoli, npm).         |
-| ci       | Changes to our CI configuration files and scripts (example scopes: Travis, Circle, BrowserStack, SauceLabs). |
-| chore    | Other changes that don't modify src or test files.                                                           |
-| revert   | Reverts a previous commit.                                                                                   |
-
-### Scopes
-
-Scopes define what part of the code changed.
+The commit message guidelines adheres to [Conventional Commits](https://www.conventionalcommits.org/) and [Semantic Versioning](https://semver.org/) for releases.
--- a/7
+++ b/7
@ -8,8 +8,11 @@ INPUT = ./
 INPUT_ENCODING = UTF-8
 USE_MDFILE_AS_MAINPAGE = README.md
 FILE_PATTERNS = *.h \
-  README.md
-HTML_EXTRA_STYLESHEET  = doxygen-awesome-css/doxygen-awesome.css
+  README.md \
+  CODE_OF_CONDUCT.md \
+  CONTRIBUTING.md \
+  LICENSE
+HTML_EXTRA_STYLESHEET = doxygen-awesome-css/doxygen-awesome.css

 RECURSIVE = YES
 EXCLUDE = test doxygen-awesome-css node_modules
--- a/4
+++ b/4
@ -1,6 +1,6 @@
-MIT License
+# MIT License

-Copyright (c) Divlo
+Copyright (c) Théo LUDWIG <contact@theoludwig.fr>

 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
--- a/15
+++ b/15
@ -1,6 +1,7 @@
 LIBRARY_NAME = libcproject
 CC = gcc
-CC_FLAGS = -Wall -Wextra -Wfloat-equal -Wundef -Werror -std=c17 -pedantic -pedantic-errors -I./
+CC_FLAGS = -Wall -Wextra -Wfloat-equal -Wundef -Werror -std=c17 -pedantic -pedantic-errors -O3 -I./
+CC_SANITIZER_FLAGS = -fsanitize=address -fsanitize=undefined
 LIB = ./build/${LIBRARY_NAME}.a
 LIB_CC_FLAGS = -L. -l:${LIB}
 LIB_SOURCES = $(wildcard lib/*.c)
@ -8,9 +9,9 @@ LIB_OBJECTS = $(patsubst %.c, %.o, $(LIB_SOURCES))
 TEST_SOURCES = $(wildcard test/*.c)
 TEST_OBJECTS = $(patsubst %.c, %.o, $(TEST_SOURCES))
 HEADER_FILES = $(wildcard lib/*.h) $(wildcard test/*.h) ./${LIBRARY_NAME}.h
-MAIN_EXECUTABLE = bin/main.exe
-SET_VERSION_EXECUTABLE = bin/set_version.exe
-TEST_EXECUTABLE = bin/test.exe
+MAIN_EXECUTABLE = bin/main
+SET_VERSION_EXECUTABLE = bin/set_version
+TEST_EXECUTABLE = bin/test

 ${LIB}: $(addprefix build/, ${LIB_OBJECTS})
 	rm --force ${LIB}
@ -31,18 +32,18 @@ build/test/%.o: test/%.c ${HEADER_FILES} | build/test
 .PHONY: run
 run: ${LIB} ./main.c
 	mkdir --parents ./bin
-	${CC} ${CC_FLAGS} -o ${MAIN_EXECUTABLE} ./main.c ${LIB_CC_FLAGS}
+	${CC} ${CC_FLAGS} ${CC_SANITIZER_FLAGS} -o ${MAIN_EXECUTABLE} ./main.c ${LIB_CC_FLAGS}
 	./${MAIN_EXECUTABLE} ${ARGS}

 .PHONY: set_version
 set_version: ${LIB} ./set_version.c
 	mkdir --parents ./bin
-	${CC} ${CC_FLAGS} -o ${SET_VERSION_EXECUTABLE} ./set_version.c ${LIB_CC_FLAGS}
+	${CC} ${CC_FLAGS} ${CC_SANITIZER_FLAGS} -o ${SET_VERSION_EXECUTABLE} ./set_version.c ${LIB_CC_FLAGS}

 .PHONY: test
 test: ${LIB} $(addprefix build/, ${TEST_OBJECTS})
 	mkdir --parents ./bin
-	${CC} ${CC_FLAGS} -o ${TEST_EXECUTABLE} $(addprefix build/, ${TEST_OBJECTS}) ${LIB_CC_FLAGS}
+	${CC} ${CC_FLAGS} ${CC_SANITIZER_FLAGS} -o ${TEST_EXECUTABLE} $(addprefix build/, ${TEST_OBJECTS}) ${LIB_CC_FLAGS}
 	./${TEST_EXECUTABLE} ${ARGS}

 .PHONY: lint
--- a/README.md
+++ b/README.md
@ -5,11 +5,11 @@
 </p>

 <p align="center">
-  <a href="./CONTRIBUTING.md"><img src="https://img.shields.io/badge/PRs-welcome-brightgreen.svg?style=flat" /></a>
+  <a href="./CONTRIBUTING.md"><img src="https://img.shields.io/badge/PRs-welcome-brightgreen.svg?style=flat" alt="Contributing" /></a>
  <a href="./LICENSE"><img src="https://img.shields.io/badge/licence-MIT-blue.svg" alt="Licence MIT"/></a>
  <a href="./CODE_OF_CONDUCT.md"><img src="https://img.shields.io/badge/Contributor%20Covenant-v2.0%20adopted-ff69b4.svg" alt="Contributor Covenant" /></a>
  <br />
-  <a href="https://github.com/Divlo/libcproject/actions/workflows/ci.yml"><img src="https://github.com/Divlo/libcproject/actions/workflows/ci.yml/badge.svg?branch=develop" /></a>
+  <a href="https://github.com/theoludwig/libcproject/actions/workflows/ci.yml"><img src="https://github.com/theoludwig/libcproject/actions/workflows/ci.yml/badge.svg?branch=develop" alt="CI" /></a>
  <a href="https://conventionalcommits.org"><img src="https://img.shields.io/badge/Conventional%20Commits-1.0.0-yellow.svg" alt="Conventional Commits" /></a>
  <a href="https://github.com/semantic-release/semantic-release"><img src="https://img.shields.io/badge/%20%20%F0%9F%93%A6%F0%9F%9A%80-semantic--release-e10079.svg" alt="semantic-release" /></a>
 </p>
@ -20,7 +20,7 @@

 C is a low-level programming language and we often end up reinventing the wheel as the C standard library (`libc`) is quite small and in my humble opinion, not well designed.

-**libcproject** solve this by providing common functions or data structures (`dictionary`, `linked_list`, `queue`, `stack`, etc.) we might need in our C projects.
+**libcproject** solve this by providing common functions or data structures (`hash_map`, `array_list`, `linked_list`, `queue`, `stack`, etc.), we might need in our C projects.

 [Online documentation](https://libcproject.vercel.app/).

@ -36,8 +36,11 @@ C is a low-level programming language and we often end up reinventing the wheel
 For example on GNU/Linux Ubuntu:

 ```sh
-sudo apt-get install build-essential gcc make clang-format
-sudo apt-get install doxygen doxygen-gui doxygen-doc graphviz
+# Install Build Tools
+sudo apt install build-essential gcc make clang-format
+
+# Install Documentation Tools
+sudo apt install doxygen doxygen-gui doxygen-doc graphviz
 ```

 ## Usage
@ -55,11 +58,18 @@ nm ./build/libcproject.a # to see the symbols

 Steps to create a new C project that uses `libcproject`:

-### Step 1: Install and Compile `libcproject`
+### Step 1: Create a new project
+
+```sh
+mkdir my-project
+cd my-project
+```
+
+### Step 2: Install and Compile `libcproject` in the project

 ```sh
 # Clone the repository
-git clone https://github.com/Divlo/libcproject.git
+git clone git@github.com:theoludwig/libcproject.git

 # Go to libcproject directory
 cd libcproject
@ -68,25 +78,10 @@ cd libcproject
 make
 ```

-### Step 2: Create a new project
-
-```sh
-mkdir my-project
-cd my-project
-```
-
-### Step 3: Install `libcproject` in the project
-
-```sh
-mkdir libcproject
-cp --recursive <path-to-libcproject> ./ # copy
-# or
-ln -s <path-to-libcproject> ./ # symbolic link
-```
-
-### Step 4: Create a new C file
+### Step 3: Create a new C file

 ```sh
+cd ..
 touch main.c
 ```

@ -97,17 +92,17 @@ touch main.c
 #include "libcproject/libcproject.h"

 int main() {
-  char* string = "Hello, world!";
+  string_t string = "Hello, world!"; // `string_t` is a typedef from `libcproject`
  printf("%s\n", string);
  printf("string_length = %ld\n", string_get_length(string)); // `string_get_length` is a function from `libcproject`
  return EXIT_SUCCESS;
 }
 ```

-### Step 5: Compile your project and link it with the library
+### Step 4: Compile your project and link it with the library

 ```sh
-gcc -o ./main.exe ./main.c -L. -l:./libcproject/build/libcproject.a
+gcc -o ./main ./main.c -L. -l:./libcproject/build/libcproject.a
 ```

 ## 💡 Contributing
--- a/2
+++ b/2
--- a/lib/array_list.c
+++ b/lib/array_list.c
@ -25,8 +25,8 @@ void array_list_remove(struct array_list* list, size_t index) {
  if (index >= list->size) {
    return;
  }
-  for (size_t i = index + 1; i < list->size - 1; i++) {
-    list->data[i - 1] = list->data[i];
+  for (size_t i = index; i < list->size - 1; i++) {
+    list->data[i] = list->data[i + 1];
  }
  list->size--;
 }
@ -37,3 +37,8 @@ void* array_list_get(struct array_list* list, size_t index) {
  }
  return list->data[index];
 }
+
+void array_list_free(struct array_list* list) {
+  free(list->data);
+  free(list);
+}
--- a/lib/array_list.h
+++ b/lib/array_list.h
@ -1,23 +1,64 @@
-#ifndef __ARRAY_LIST__
-#define __ARRAY_LIST__
+#ifndef __LIBCPROJECT_ARRAY_LIST__
+#define __LIBCPROJECT_ARRAY_LIST__

+#include <errno.h>
 #include <stdbool.h>
 #include <stdlib.h>

+#include "types.h"
+
 #define ARRAY_LIST_INITIAL_CAPACITY 10

+/**
+ * @brief A dynamic array implementation.
+ * @since v1.2.0
+ */
 struct array_list {
  void** data;
  size_t size;
  size_t capacity;
 };

+/**
+ * @brief Initializes a new array list.
+ * @since v1.2.0
+ */
 struct array_list* array_list_initialization();

+/**
+ * @brief Adds an element to the end of the array list.
+ *
+ * @param list
+ * @param element
+ * @since v1.2.0
+ */
 void array_list_add(struct array_list* list, void* element);

+/**
+ * @brief Removes an element from the array list.
+ *
+ * @param list
+ * @param index
+ * @since v1.2.0
+ */
 void array_list_remove(struct array_list* list, size_t index);

+/**
+ * @brief Gets an element from the array list.
+ *
+ * @param list
+ * @param index
+ * @return void*
+ * @since v1.2.0
+ */
 void* array_list_get(struct array_list* list, size_t index);

+/**
+ * @brief Frees the array list.
+ *
+ * @param list
+ * @since v3.0.0
+ */
+void array_list_free(struct array_list* list);
+
 #endif
--- a/lib/character.c
+++ b/lib/character.c
@ -1,11 +1,11 @@
 #include "character.h"

-void character_append(char* string, const char character) {
+void character_append(string_t string, const char character) {
  size_t length = string_get_length(string);
  character_append_at(string, character, length);
 }

-void character_append_at(char* string, const char character, const size_t index) {
+void character_append_at(string_t string, const char character, const size_t index) {
  size_t length = string_get_length(string);
  for (size_t index_string = length; index_string > index; index_string--) {
    string[index_string] = string[index_string - 1];
--- a/lib/character.h
+++ b/lib/character.h
@ -1,10 +1,12 @@
-#ifndef __CHARACTER__
-#define __CHARACTER__
+#ifndef __LIBCPROJECT_CHARACTER__
+#define __LIBCPROJECT_CHARACTER__

+#include <errno.h>
 #include <stdbool.h>
 #include <stdlib.h>

 #include "string.h"
+#include "types.h"

 /**
 * @brief Append a character to a string, assuming string points to an array
@ -12,8 +14,9 @@
 *
 * @param string
 * @param character
+ * @since v1.0.0
 */
-void character_append(char* string, char character);
+void character_append(string_t string, char character);

 /**
 * @brief Append a character to a string at a specific index, assuming string points to an array with enough space.
@ -21,14 +24,15 @@ void character_append(char* string, char character);
 * @param string
 * @param character
 * @param index
+ * @since v1.0.0
 */
-void character_append_at(char* string, const char character, const size_t index);
+void character_append_at(string_t string, const char character, const size_t index);

 /**
 * @brief Converts the character to uppercase.
 *
 * @param character
- * @return const char
+ * @since v1.0.0
 */
 char character_to_upper(const char character);

@ -36,16 +40,17 @@ char character_to_upper(const char character);
 * @brief Converts the character to lowercase.
 *
 * @param character
- * @return const char
+ * @since v1.0.0
 */
 char character_to_lower(const char character);

 /**
 * @brief Check if the character is a digit ('0', '1', '2', '3', '4', '5', '6', '7, '8' or '9').
 *
- * @param string1
- * @param string2
- * @return true if the character is a digit, false otherwise
+ * @param character
+ * @return true
+ * @return false
+ * @since v1.0.0
 */
 bool character_get_is_digit(const char character);

@ -54,7 +59,8 @@ bool character_get_is_digit(const char character);
 * Return 0 if the character is not a letter.
 *
 * @param character
- * @return char
+ * @return unsigned char
+ * @since v1.0.0
 */
 unsigned char character_get_alphabet_position(const char character);

--- a/lib/convert.c
+++ b/lib/convert.c
@ -1,11 +1,13 @@
 #include "convert.h"

-char* convert_character_to_string(const char character) {
-  char* string = malloc(sizeof(char*) * 2);
+string_t convert_character_to_string(const char character) {
+  string_t string = malloc(sizeof(char) * 2);
  if (string == NULL) {
+    perror("Error (convert_character_to_string)");
    exit(EXIT_FAILURE);
  }
-  character_append(string, character);
+  string[0] = character;
+  string[1] = '\0';
  return string;
 }

@ -17,7 +19,7 @@ char convert_digit_to_character(const char digit) {
  return digit + '0';
 }

-long long convert_string_to_number(const char* string) {
+long long convert_string_to_number(const string_t string) {
  bool is_negative = string[0] == '-';
  long long integer = 0;
  size_t length = string_get_length(string);
@ -27,32 +29,40 @@ long long convert_string_to_number(const char* string) {
  return is_negative ? integer * -1 : integer;
 }

-char* convert_number_to_string(const long long integer) {
+string_t convert_number_to_string(const long long integer) {
  if (integer == 0) {
    return convert_character_to_string('0');
  }
  bool is_negative = integer < 0;
  size_t length = 1;
-  char* string = malloc(sizeof(char*) * length);
-  if (string == NULL) {
-    exit(EXIT_FAILURE);
-  }
  long long current = mathematics_absolute_value(integer);
  while (current != 0) {
-    character_append(string, convert_digit_to_character(current % 10));
    current = current / 10;
    length++;
-    string = realloc(string, sizeof(char*) * length);
  }
  if (is_negative) {
-    character_append(string, '-');
    length++;
-    string = realloc(string, sizeof(char*) * length);
  }
-  return string_reverse(string);
+  string_t string = malloc(sizeof(char) * length);
+  if (string == NULL) {
+    perror("Error (convert_number_to_string)");
+    exit(EXIT_FAILURE);
+  }
+  current = mathematics_absolute_value(integer);
+  size_t index = 0;
+  while (current != 0) {
+    string[index++] = convert_digit_to_character(current % 10);
+    current = current / 10;
+  }
+  if (is_negative) {
+    string[index++] = '-';
+  }
+  string[index] = '\0';
+  string_reverse(string);
+  return string;
 }

-char* convert_number_from_base_10_to_base(unsigned long long number, unsigned int base) {
+string_t convert_number_from_base_10_to_base(unsigned long long number, unsigned long base) {
  if (number == 0) {
    return "0";
  }
@ -63,7 +73,7 @@ char* convert_number_from_base_10_to_base(unsigned long long number, unsigned in
    number = number / base;
    index++;
  }
-  char* result = malloc(sizeof(char) * (index + 1));
+  string_t result = malloc(sizeof(char) * (index + 1));
  int index_result = 0;
  for (int iteration = index - 1; iteration >= 0; iteration--) {
    int remainder = remainders[iteration];
@ -74,13 +84,14 @@ char* convert_number_from_base_10_to_base(unsigned long long number, unsigned in
    }
    index_result++;
  }
+  result[index_result] = '\0';
  return result;
 }

-int convert_number_from_base_to_base_10(char* number, unsigned int base) {
-  int length = string_get_length(number);
+unsigned long convert_number_from_base_to_base_10(string_t number, unsigned long base) {
+  size_t length = string_get_length(number);
  int exponent = length - 1;
-  int result = 0;
+  unsigned long result = 0;
  int index = 0;
  while (exponent >= 0) {
    int current_number = (int)(number[index] - '0');
@ -96,6 +107,6 @@ int convert_number_from_base_to_base_10(char* number, unsigned int base) {
  return result;
 }

-char* convert_number_from_base_to_another(char* number, int base_from, int base_target) {
+string_t convert_number_from_base_to_another(string_t number, unsigned long base_from, unsigned long base_target) {
  return convert_number_from_base_10_to_base(convert_number_from_base_to_base_10(number, base_from), base_target);
 }
--- a/lib/convert.h
+++ b/lib/convert.h
@ -1,6 +1,7 @@
-#ifndef __CONVERT__
-#define __CONVERT__
+#ifndef __LIBCPROJECT_CONVERT__
+#define __LIBCPROJECT_CONVERT__

+#include <errno.h>
 #include <stdio.h>
 #include <stdlib.h>

@ -8,21 +9,82 @@
 #include "mathematics.h"
 #include "stdbool.h"
 #include "string.h"
+#include "types.h"

-char* convert_character_to_string(const char character);
+/**
+ * @brief Convert a character to a string.
+ *
+ * @param character
+ * @return string_t
+ * @since v1.0.0
+ */
+string_t convert_character_to_string(const char character);

+/**
+ * @brief Convert a character to a digit.
+ *
+ * @param character
+ * @return char
+ * @since v1.0.0
+ */
 char convert_character_to_digit(const char character);

+/**
+ * @brief Convert a digit to a character.
+ *
+ * @param digit
+ * @return char
+ * @since v1.0.0
+ */
 char convert_digit_to_character(const char digit);

-long long convert_string_to_number(const char* string);
+/**
+ * @brief Convert a string to a number.
+ *
+ * @param string
+ * @return long long
+ * @since v1.0.0
+ */
+long long convert_string_to_number(const string_t string);

-char* convert_number_to_string(const long long integer);
+/**
+ * @brief Convert a number to a string.
+ *
+ * @param integer
+ * @return string_t
+ * @since v1.0.0
+ */
+string_t convert_number_to_string(const long long integer);

-char* convert_number_from_base_10_to_base(unsigned long long number, unsigned int base);
+/**
+ * @brief Convert a number (base 10) to a string with a specific base.
+ *
+ * @param number
+ * @param base
+ * @return string_t
+ * @since v1.0.0
+ */
+string_t convert_number_from_base_10_to_base(unsigned long long number, unsigned long base);

-int convert_number_from_base_to_base_10(char* number, unsigned int base);
+/**
+ * @brief Convert a number with a specific base to a number base 10.
+ *
+ * @param number
+ * @param base
+ * @return int
+ * @since v1.0.0
+ */
+unsigned long convert_number_from_base_to_base_10(string_t number, unsigned long base);

-char* convert_number_from_base_to_another(char* number, int base_from, int base_target);
+/**
+ * @brief Convert a number with a specific base to a number of specific base.
+ *
+ * @param number
+ * @param base_from
+ * @param base_target
+ * @return string_t
+ * @since v1.0.0
+ */
+string_t convert_number_from_base_to_another(string_t number, unsigned long base_from, unsigned long base_target);

 #endif
--- a/lib/dictionary.c
+++ b/lib/dictionary.c
@ -1,64 +0,0 @@
-#include "dictionary.h"
-
-struct dictionary *dictionary_initialization() {
-  struct dictionary *dictionary = malloc(sizeof(struct dictionary));
-  dictionary->items = malloc(sizeof(struct dictionary_item *) * DICTIONARY_INITIAL_CAPACITY);
-  dictionary->length = 0;
-  dictionary->capacity = DICTIONARY_INITIAL_CAPACITY;
-  for (size_t index = 0; index < dictionary->capacity; index++) {
-    dictionary->items[index] = NULL;
-  }
-  return dictionary;
-}
-
-void dictionary_add(struct dictionary *dictionary, char *key, void *data) {
-  if (dictionary->length == dictionary->capacity) {
-    size_t previous_capacity = dictionary->capacity;
-    dictionary->capacity += DICTIONARY_INITIAL_CAPACITY;
-    dictionary->items = realloc(dictionary->items, sizeof(struct dictionary_item *) * dictionary->capacity);
-    for (size_t index = previous_capacity; index < dictionary->capacity; index++) {
-      dictionary->items[index] = NULL;
-    }
-  }
-  struct dictionary_item *item = NULL;
-  for (size_t index = 0; index < dictionary->length && item == NULL; index++) {
-    if (string_equals(key, dictionary->items[index]->key)) {
-      item = dictionary->items[index];
-    }
-  }
-  if (item == NULL) {
-    item = malloc(sizeof(struct dictionary_item));
-    item->key = key;
-    item->data = data;
-    dictionary->items[dictionary->length] = item;
-    dictionary->length++;
-  } else {
-    item->data = data;
-  }
-}
-
-void dictionary_remove(struct dictionary *dictionary, char *key) {
-  bool found = false;
-  for (size_t index = 0; index < dictionary->length && !found; index++) {
-    if (string_equals(key, dictionary->items[index]->key)) {
-      free(dictionary->items[index]);
-      dictionary->items[index] = dictionary->items[dictionary->length - 1];
-      dictionary->length--;
-      found = true;
-    }
-  }
-}
-
-struct dictionary_item *dictionary_get(struct dictionary *dictionary, char *key) {
-  for (size_t index = 0; index < dictionary->length; index++) {
-    struct dictionary_item *item = dictionary->items[index];
-    if (string_equals(key, item->key)) {
-      return item;
-    }
-  }
-  return NULL;
-}
-
-bool dictionary_contains_key(struct dictionary *dictionary, char *key) {
-  return dictionary_get(dictionary, key) != NULL;
-}
--- a/lib/dictionary.h
+++ b/lib/dictionary.h
@ -1,34 +0,0 @@
-#ifndef __DICTIONARY__
-#define __DICTIONARY__
-
-#include <stdbool.h>
-#include <stdlib.h>
-
-#include "string.h"
-
-#define DICTIONARY_INITIAL_CAPACITY 10
-
-// Dictionary implementation with O(n) lookup complexity.
-struct dictionary {
-  struct dictionary_item **items;
-
-  size_t length;
-  size_t capacity;
-};
-
-struct dictionary_item {
-  void *data;
-  char *key;
-};
-
-struct dictionary *dictionary_initialization();
-
-void dictionary_add(struct dictionary *dictionary, char *key, void *data);
-
-void dictionary_remove(struct dictionary *dictionary, char *key);
-
-struct dictionary_item *dictionary_get(struct dictionary *dictionary, char *key);
-
-bool dictionary_contains_key(struct dictionary *dictionary, char *key);
-
-#endif
--- a/lib/filesystem.c
+++ b/lib/filesystem.c
@ -1,6 +1,6 @@
 #include "filesystem.h"

-int filesystem_read(char *path, char **file_content, off_t *file_size) {
+int filesystem_read(string_t path, byte_t **file_content, off_t *file_size) {
  int file_descriptor = open(path, O_RDONLY);
  if (file_descriptor == -1) {
    return -1;
@ -8,39 +8,243 @@ int filesystem_read(char *path, char **file_content, off_t *file_size) {
  (*file_size) = lseek(file_descriptor, 0, SEEK_END);
  lseek(file_descriptor, 0, SEEK_SET);
  (*file_content) = malloc(*file_size);
-  read(file_descriptor, *file_content, *file_size);
+  if (read(file_descriptor, *file_content, *file_size) == -1) {
+    return -1;
+  }
  close(file_descriptor);
  return 0;
 }

-int filesystem_write(char *path, char *file_content, off_t file_size) {
+int filesystem_write(string_t path, byte_t *file_content, off_t file_size) {
  int file_descriptor = open(path, O_WRONLY | O_CREAT | O_TRUNC, 0644);
  if (file_descriptor == -1) {
    return -1;
  }
-  write(file_descriptor, file_content, file_size);
+  if (write(file_descriptor, file_content, file_size) == -1) {
+    return -1;
+  }
  close(file_descriptor);
  return 0;
 }

-char *filesystem_get_mimetype(char *path) {
-  if (string_ends_with(path, ".html")) {
-    return "text/html";
+bool filesystem_exists(string_t path) {
+  return access(path, F_OK) == 0;
+}
+
+int filesystem_remove(string_t path) {
+  return remove(path);
+}
+
+string_t filesystem_get_mimetype(string_t path) {
+  if (string_ends_with(path, ".aac")) {
+    return "audio/aac";
+  }
+  if (string_ends_with(path, ".abw")) {
+    return "application/x-abiword";
+  }
+  if (string_ends_with(path, ".arc")) {
+    return "application/x-freearc";
+  }
+  if (string_ends_with(path, ".avif")) {
+    return "image/avif";
+  }
+  if (string_ends_with(path, ".avi")) {
+    return "video/x-msvideo";
+  }
+  if (string_ends_with(path, ".azw")) {
+    return "application/vnd.amazon.ebook";
+  }
+  if (string_ends_with(path, ".bin")) {
+    return "application/octet-stream";
+  }
+  if (string_ends_with(path, ".bmp")) {
+    return "image/bmp";
+  }
+  if (string_ends_with(path, ".bz")) {
+    return "application/x-bzip";
+  }
+  if (string_ends_with(path, ".bz2")) {
+    return "application/x-bzip2";
+  }
+  if (string_ends_with(path, ".cda")) {
+    return "application/x-cdf";
+  }
+  if (string_ends_with(path, ".csh")) {
+    return "application/x-csh";
  }
  if (string_ends_with(path, ".css")) {
    return "text/css";
  }
-  if (string_ends_with(path, ".js")) {
-    return "text/javascript";
+  if (string_ends_with(path, ".csv")) {
+    return "text/csv";
  }
-  if (string_ends_with(path, ".png")) {
-    return "image/png";
+  if (string_ends_with(path, ".doc")) {
+    return "application/msword";
  }
-  if (string_ends_with(path, ".jpg") || string_ends_with(path, ".jpeg")) {
-    return "image/jpeg";
+  if (string_ends_with(path, ".docx")) {
+    return "application/vnd.openxmlformats-officedocument.wordprocessingml.document";
+  }
+  if (string_ends_with(path, ".eot")) {
+    return "application/vnd.ms-fontobject";
+  }
+  if (string_ends_with(path, ".epub")) {
+    return "application/epub+zip";
+  }
+  if (string_ends_with(path, ".gz")) {
+    return "application/gzip";
  }
  if (string_ends_with(path, ".gif")) {
    return "image/gif";
  }
-  return "text/plain";
+  if (string_ends_with(path, ".htm") || string_ends_with(path, ".html")) {
+    return "text/html";
+  }
+  if (string_ends_with(path, ".ico")) {
+    return "image/vnd.microsoft.icon";
+  }
+  if (string_ends_with(path, ".ics")) {
+    return "text/calendar";
+  }
+  if (string_ends_with(path, ".jar")) {
+    return "application/java-archive";
+  }
+  if (string_ends_with(path, ".jpg") || string_ends_with(path, ".jpeg") || string_ends_with(path, ".jpe") || string_ends_with(path, ".jif") || string_ends_with(path, ".jfif") || string_ends_with(path, ".jfi")) {
+    return "image/jpeg";
+  }
+  if (string_ends_with(path, ".js") || string_ends_with(path, ".mjs") || string_ends_with(path, ".cjs")) {
+    return "text/javascript";
+  }
+  if (string_ends_with(path, ".json")) {
+    return "application/json";
+  }
+  if (string_ends_with(path, ".jsonld")) {
+    return "application/ld+json";
+  }
+  if (string_ends_with(path, ".mid") || string_ends_with(path, ".midi")) {
+    return "audio/midi";
+  }
+  if (string_ends_with(path, ".mp3")) {
+    return "audio/mpeg";
+  }
+  if (string_ends_with(path, ".mp4")) {
+    return "video/mp4";
+  }
+  if (string_ends_with(path, ".mpeg")) {
+    return "video/mpeg";
+  }
+  if (string_ends_with(path, ".mpkg")) {
+    return "application/vnd.apple.installer+xml";
+  }
+  if (string_ends_with(path, ".odp")) {
+    return "application/vnd.oasis.opendocument.presentation";
+  }
+  if (string_ends_with(path, ".ods")) {
+    return "application/vnd.oasis.opendocument.spreadsheet";
+  }
+  if (string_ends_with(path, ".odt")) {
+    return "application/vnd.oasis.opendocument.text";
+  }
+  if (string_ends_with(path, ".oga")) {
+    return "audio/ogg";
+  }
+  if (string_ends_with(path, ".ogv")) {
+    return "video/ogg";
+  }
+  if (string_ends_with(path, ".ogx")) {
+    return "application/ogg";
+  }
+  if (string_ends_with(path, ".opus")) {
+    return "audio/opus";
+  }
+  if (string_ends_with(path, ".otf")) {
+    return "font/otf";
+  }
+  if (string_ends_with(path, ".png")) {
+    return "image/png";
+  }
+  if (string_ends_with(path, ".pdf")) {
+    return "application/pdf";
+  }
+  if (string_ends_with(path, ".php")) {
+    return "application/x-httpd-php";
+  }
+  if (string_ends_with(path, ".ppt")) {
+    return "application/vnd.ms-powerpoint";
+  }
+  if (string_ends_with(path, ".pptx")) {
+    return "application/vnd.openxmlformats-officedocument.presentationml.presentation";
+  }
+  if (string_ends_with(path, ".rar")) {
+    return "application/vnd.rar";
+  }
+  if (string_ends_with(path, ".rtf")) {
+    return "application/rtf";
+  }
+  if (string_ends_with(path, ".sh")) {
+    return "application/x-sh";
+  }
+  if (string_ends_with(path, ".svg")) {
+    return "image/svg+xml";
+  }
+  if (string_ends_with(path, ".tar")) {
+    return "application/x-tar";
+  }
+  if (string_ends_with(path, ".tif") || string_ends_with(path, ".tiff")) {
+    return "image/tiff";
+  }
+  if (string_ends_with(path, ".ts")) {
+    return "application/typescript";
+  }
+  if (string_ends_with(path, ".ttf")) {
+    return "font/ttf";
+  }
+  if (string_ends_with(path, ".txt")) {
+    return "text/plain";
+  }
+  if (string_ends_with(path, ".vsd")) {
+    return "application/vnd.visio";
+  }
+  if (string_ends_with(path, ".wav")) {
+    return "audio/wav";
+  }
+  if (string_ends_with(path, ".weba") || string_ends_with(path, ".webm")) {
+    return "audio/webm";
+  }
+  if (string_ends_with(path, ".webp")) {
+    return "image/webp";
+  }
+  if (string_ends_with(path, ".woff")) {
+    return "font/woff";
+  }
+  if (string_ends_with(path, ".woff2")) {
+    return "font/woff2";
+  }
+  if (string_ends_with(path, ".xhtml")) {
+    return "application/xhtml+xml";
+  }
+  if (string_ends_with(path, ".xls")) {
+    return "application/vnd.ms-excel";
+  }
+  if (string_ends_with(path, ".xlsx")) {
+    return "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet";
+  }
+  if (string_ends_with(path, ".xml")) {
+    return "application/xml";
+  }
+  if (string_ends_with(path, ".xul")) {
+    return "application/vnd.mozilla.xul+xml";
+  }
+  if (string_ends_with(path, ".zip")) {
+    return "application/zip";
+  }
+  if (string_ends_with(path, ".3gp")) {
+    return "video/3gpp";
+  }
+  if (string_ends_with(path, ".3g2")) {
+    return "video/3gpp2";
+  }
+  if (string_ends_with(path, ".7z")) {
+    return "application/x-7z-compressed";
+  }
+  return "application/octet-stream";
 }
--- a/lib/filesystem.h
+++ b/lib/filesystem.h
@ -1,5 +1,5 @@
-#ifndef __FILESYSTEM__
-#define __FILESYSTEM__
+#ifndef __LIBCPROJECT_FILESYSTEM__
+#define __LIBCPROJECT_FILESYSTEM__

 #include <dirent.h>
 #include <errno.h>
@ -11,18 +11,20 @@
 #include <unistd.h>

 #include "string.h"
+#include "types.h"

 /**
 * @brief Read the content of a file.
 *
 * @param path
 * @param file_content
- * @param file_size
+ * @param file_size The size of the file that was read (mutated by the function).
+ * @retval -1 if the file does not exist or if there is an error.
+ * @retval 0 for success.
 * @return int
- * @retval -1 if the file does not exist
- * @retval 0 for success
+ * @since v1.0.0
 */
-int filesystem_read(char *path, char **file_content, off_t *file_size);
+int filesystem_read(string_t path, byte_t **file_content, off_t *file_size);

 /**
 * @brief Write the content to a file.
@ -30,18 +32,44 @@ int filesystem_read(char *path, char **file_content, off_t *file_size);
 * @param path
 * @param file_content
 * @param file_size
+ * @retval -1 if there is an error.
+ * @retval 0 for success.
 * @return int
- * @retval -1 if errors
- * @retval 0 for success
+ * @since v1.0.0
 */
-int filesystem_write(char *path, char *file_content, off_t file_size);
+int filesystem_write(string_t path, byte_t *file_content, off_t file_size);

 /**
- * @brief Get the mimetype of a file.
+ * @brief Check if a path exists.
 *
 * @param path
- * @return char*
+ * @return true
+ * @return false
+ * @since v3.1.0
 */
-char *filesystem_get_mimetype(char *path);
+bool filesystem_exists(string_t path);
+
+/**
+ * @brief Removes a path.
+ *
+ * @param path
+ * @return int
+ * @retval -1 if there is an error.
+ * @retval 0 for success.
+ * @return int
+ * @since v3.1.0
+ */
+int filesystem_remove(string_t path);
+
+/**
+ * @brief Get the mimetype of a file based on its extension.
+ *
+ * @param path
+ * @see https://developer.mozilla.org/en-US/docs/Web/HTTP/Basics_of_HTTP/MIME_types/Common_types
+ * @see https://www.iana.org/assignments/media-types/media-types.xhtml
+ * @return string_t
+ * @since v1.0.0
+ */
+string_t filesystem_get_mimetype(string_t path);

 #endif
--- a/lib/hash_map.c
+++ b/lib/hash_map.c
@ -0,0 +1,244 @@
+#include "hash_map.h"
+
+#define ROTATE_LEFT(x, b) (((x) << (b)) | ((x) >> (64 - (b))))
+
+uint64_t sip_round(uint64_t v0, uint64_t v1, uint64_t v2, uint64_t v3) {
+  v0 += v1;
+  v2 += v3;
+  v1 = ROTATE_LEFT(v1, 13);
+  v3 = ROTATE_LEFT(v3, 16);
+  v1 ^= v0;
+  v3 ^= v2;
+  v0 = ROTATE_LEFT(v0, 32);
+  v2 += v1;
+  v0 += v3;
+  v1 = ROTATE_LEFT(v1, 17);
+  v3 = ROTATE_LEFT(v3, 21);
+  v1 ^= v2;
+  v3 ^= v0;
+  v2 = ROTATE_LEFT(v2, 32);
+  return v0;
+}
+
+uint64_t hash(string_t key, size_t capacity) {
+  size_t key_length = string_get_length(key);
+  const uint64_t c = 0x736f6d6570736575;
+  uint64_t v0 = c ^ 0x736f6d6570736575;
+  uint64_t v1 = c ^ 0x646f72616e646f6d;
+  uint64_t v2 = c ^ 0x6c7967656e657261;
+  uint64_t v3 = c ^ 0x7465646279746573;
+
+  uint64_t m;
+  uint64_t hash;
+
+  uint8_t *message = (uint8_t *)key;
+
+  size_t remaining = key_length;
+  size_t offset = 0;
+
+  while (remaining >= 8) {
+    memcpy(&m, message + offset, sizeof(uint64_t));
+    v3 ^= m;
+
+    for (int i = 0; i < 2; i++) {
+      v0 = sip_round(v0, v1, v2, v3);
+      v1 = ROTATE_LEFT(v1, 13);
+      v2 = ROTATE_LEFT(v2, 16);
+      v3 = ROTATE_LEFT(v3, 32);
+      v0 ^= m;
+    }
+
+    v2 ^= 0xff;
+    for (int i = 0; i < 4; i++) {
+      v0 = sip_round(v0, v1, v2, v3);
+      v1 = ROTATE_LEFT(v1, 13);
+      v2 = ROTATE_LEFT(v2, 16);
+      v3 = ROTATE_LEFT(v3, 32);
+    }
+
+    hash = v0 ^ v1 ^ v2 ^ v3;
+    remaining -= sizeof(uint64_t);
+    offset += sizeof(uint64_t);
+  }
+
+  m = (uint64_t)remaining << 56;
+  switch (remaining) {
+    case 7:
+      m |= (uint64_t)message[offset + 6] << 48;
+      break;
+    case 6:
+      m |= (uint64_t)message[offset + 5] << 40;
+      break;
+    case 5:
+      m |= (uint64_t)message[offset + 4] << 32;
+      break;
+    case 4:
+      m |= (uint64_t)message[offset + 3] << 24;
+      break;
+    case 3:
+      m |= (uint64_t)message[offset + 2] << 16;
+      break;
+    case 2:
+      m |= (uint64_t)message[offset + 1] << 8;
+      break;
+    case 1:
+      m |= (uint64_t)message[offset];
+      break;
+    default:
+      break;
+  }
+
+  v3 ^= m;
+
+  for (int i = 0; i < 2; i++) {
+    v0 = sip_round(v0, v1, v2, v3);
+    v1 = ROTATE_LEFT(v1, 13);
+    v2 = ROTATE_LEFT(v2, 16);
+    v3 = ROTATE_LEFT(v3, 32);
+  }
+
+  v0 ^= m;
+  v2 ^= 0xff;
+
+  for (int i = 0; i < 4; i++) {
+    v0 = sip_round(v0, v1, v2, v3);
+    v1 = ROTATE_LEFT(v1, 13);
+    v2 = ROTATE_LEFT(v2, 16);
+    v3 = ROTATE_LEFT(v3, 32);
+  }
+
+  hash = v0 ^ v1 ^ v2 ^ v3;
+
+  return hash % capacity;
+}
+
+struct hash_map *hash_map_initialization() {
+  struct hash_map *hash_map = malloc(sizeof(struct hash_map));
+  hash_map->items = malloc(sizeof(struct linked_list *) * HASH_MAP_INITIAL_CAPACITY);
+  hash_map->length = 0;
+  hash_map->capacity = HASH_MAP_INITIAL_CAPACITY;
+  for (size_t index = 0; index < hash_map->capacity; index++) {
+    hash_map->items[index] = NULL;
+  }
+  return hash_map;
+}
+
+void hash_map_add(struct hash_map *hash_map, string_t key_value, void *data) {
+  if (hash_map->length == hash_map->capacity) {
+    size_t previous_capacity = hash_map->capacity;
+    hash_map->capacity += HASH_MAP_INITIAL_CAPACITY;
+    hash_map->items = realloc(hash_map->items, sizeof(struct linked_list *) * hash_map->capacity);
+    for (size_t index = previous_capacity; index < hash_map->capacity; index++) {
+      hash_map->items[index] = NULL;
+    }
+  }
+  string_t key = string_copy(key_value);
+  uint64_t hash_value = hash(key, hash_map->capacity);
+  struct linked_list *list = hash_map->items[hash_value];
+  struct hash_map_item *item = malloc(sizeof(struct hash_map_item));
+  item->key = key;
+  item->data = data;
+  if (list == NULL) {
+    list = linked_list_initialization();
+    hash_map->items[hash_value] = list;
+    linked_list_add_in_head(list, (void *)item);
+    hash_map->length++;
+  } else {
+    struct linked_list_node *node = list->head;
+    bool found = false;
+    while (node != NULL && !found) {
+      struct hash_map_item *item = (struct hash_map_item *)node->data;
+      if (string_equals(key, item->key)) {
+        item->data = data;
+        found = true;
+      }
+      node = node->next;
+    }
+    if (!found) {
+      linked_list_add_in_head(list, (void *)item);
+      hash_map->length++;
+    } else {
+      free(key);
+      free(item);
+    }
+  }
+}
+
+void hash_map_remove(struct hash_map *hash_map, string_t key) {
+  uint64_t hash_value = hash(key, hash_map->capacity);
+  struct linked_list *list = hash_map->items[hash_value];
+  if (list == NULL) {
+    return;
+  }
+  struct linked_list *new_list = linked_list_initialization();
+  struct linked_list_node *node = list->head;
+  while (node != NULL) {
+    struct hash_map_item *item = (struct hash_map_item *)node->data;
+    if (!string_equals(key, item->key)) {
+      linked_list_add_in_head(new_list, item);
+    } else {
+      free(item->key);
+      free(item);
+    }
+    node = node->next;
+  }
+  linked_list_free(list);
+  hash_map->items[hash_value] = new_list;
+  hash_map->length--;
+}
+
+void *hash_map_get(struct hash_map *hash_map, string_t key) {
+  uint64_t hash_value = hash(key, hash_map->capacity);
+  struct linked_list *list = hash_map->items[hash_value];
+  if (list == NULL) {
+    return NULL;
+  }
+  struct linked_list_node *node = list->head;
+  while (node != NULL) {
+    struct hash_map_item *item = (struct hash_map_item *)node->data;
+    if (string_equals(key, item->key)) {
+      return item->data;
+    }
+    node = node->next;
+  }
+  return NULL;
+}
+
+bool hash_map_contains_key(struct hash_map *hash_map, string_t key) {
+  return hash_map_get(hash_map, key) != NULL;
+}
+
+string_t *hash_map_get_keys(struct hash_map *hash_map) {
+  string_t *keys = malloc(sizeof(string_t) * hash_map->length);
+  size_t index = 0;
+  for (size_t hash_value = 0; hash_value < hash_map->capacity; hash_value++) {
+    struct linked_list *list = hash_map->items[hash_value];
+    if (list != NULL) {
+      struct linked_list_node *node = list->head;
+      while (node != NULL) {
+        struct hash_map_item *item = (struct hash_map_item *)node->data;
+        keys[index++] = item->key;
+        node = node->next;
+      }
+    }
+  }
+  return keys;
+}
+
+void hash_map_free(struct hash_map *hash_map) {
+  for (size_t index = 0; index < hash_map->capacity; index++) {
+    struct linked_list *list = hash_map->items[index];
+    if (list != NULL) {
+      struct linked_list_node *node = list->head;
+      while (node != NULL) {
+        struct hash_map_item *item = (struct hash_map_item *)node->data;
+        free(item->key);
+        free(item);
+        node = node->next;
+      }
+      linked_list_free(list);
+    }
+  }
+  free(hash_map->items);
+  free(hash_map);
+}
--- a/lib/hash_map.h
+++ b/lib/hash_map.h
@ -0,0 +1,111 @@
+#ifndef __LIBCPROJECT_HASH_MAP__
+#define __LIBCPROJECT_HASH_MAP__
+
+#include <errno.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "linked_list.h"
+#include "string.h"
+#include "types.h"
+
+#define HASH_MAP_INITIAL_CAPACITY 10
+
+/**
+ * @brief Hash map data structure.
+ * @since v2.0.0
+ */
+struct hash_map {
+  struct linked_list **items;
+
+  size_t length;
+  size_t capacity;
+};
+
+/**
+ * @brief Hash map item data structure.
+ * @since v2.0.0
+ */
+struct hash_map_item {
+  void *data;
+  string_t key;
+};
+
+/**
+ * @brief Hash function (using SipHash 1-3 algorithm).
+ * @see https://en.wikipedia.org/wiki/SipHash
+ * @see https://github.com/veorq/SipHash
+ *
+ * @param key
+ * @param capacity
+ * @return uint64_t
+ * @since v2.0.0
+ */
+uint64_t hash(string_t key, size_t capacity);
+
+/**
+ * @brief Hash map initialization.
+ *
+ * @return struct hash_map*
+ * @since v2.0.0
+ */
+struct hash_map *hash_map_initialization();
+
+/**
+ * @brief Add an item to the hash map.
+ *
+ * @param hash_map
+ * @param key
+ * @param data
+ * @since v2.0.0
+ */
+void hash_map_add(struct hash_map *hash_map, string_t key, void *data);
+
+/**
+ * @brief Remove an item from the hash map.
+ * @param hash_map
+ * @param key
+ * @since v2.0.0
+ */
+void hash_map_remove(struct hash_map *hash_map, string_t key);
+
+/**
+ * @brief Get an item from the hash map.
+ * @param hash_map
+ * @param key
+ * @return void*
+ * @since v2.0.0
+ */
+void *hash_map_get(struct hash_map *hash_map, string_t key);
+
+/**
+ * @brief Check if the hash map contains a key.
+ *
+ * @param hash_map
+ * @param key
+ * @return true
+ * @return false
+ * @since v2.0.0
+ */
+bool hash_map_contains_key(struct hash_map *hash_map, string_t key);
+
+/**
+ * @brief Get the hash map keys.
+ *
+ * @param hash_map
+ * @return string_t*
+ * @since v2.0.0
+ */
+string_t *hash_map_get_keys(struct hash_map *hash_map);
+
+/**
+ * @brief Frees the hash map.
+ *
+ * @param hash_map
+ * @since v3.0.0
+ */
+void hash_map_free(struct hash_map *hash_map);
+
+#endif
--- a/lib/linked_list.c
+++ b/lib/linked_list.c
@ -1,8 +1,9 @@
 #include "linked_list.h"

 struct linked_list *linked_list_initialization() {
-  struct linked_list *list = malloc(sizeof(*list));
+  struct linked_list *list = malloc(sizeof(struct linked_list));
  if (list == NULL) {
+    perror("Error (linked_list_initialization)");
    exit(EXIT_FAILURE);
  }
  list->head = NULL;
@ -11,8 +12,14 @@ struct linked_list *linked_list_initialization() {
 }

 struct linked_list_node *linked_list_add_in_head(struct linked_list *list, void *new_data) {
-  struct linked_list_node *node_new = malloc(sizeof(*node_new));
-  if (list == NULL || node_new == NULL) {
+  if (list == NULL) {
+    errno = EINVAL;
+    perror("Error (linked_list_add_in_head)");
+    exit(EXIT_FAILURE);
+  }
+  struct linked_list_node *node_new = malloc(sizeof(struct linked_list_node));
+  if (node_new == NULL) {
+    perror("Error (linked_list_add_in_head)");
    exit(EXIT_FAILURE);
  }
  node_new->data = new_data;
@ -24,6 +31,8 @@ struct linked_list_node *linked_list_add_in_head(struct linked_list *list, void

 void linked_list_delete_in_head(struct linked_list *list) {
  if (list == NULL) {
+    errno = EINVAL;
+    perror("Error (linked_list_delete_in_head)");
    exit(EXIT_FAILURE);
  }
  if (list->head != NULL) {
@ -35,11 +44,17 @@ void linked_list_delete_in_head(struct linked_list *list) {
 }

 struct linked_list_node *linked_list_add_after_last(struct linked_list *list, void *new_data) {
+  if (list == NULL) {
+    errno = EINVAL;
+    perror("Error (linked_list_add_after_last)");
+    exit(EXIT_FAILURE);
+  }
  if (list->head == NULL) {
    return linked_list_add_in_head(list, new_data);
  }
-  struct linked_list_node *node_new = malloc(sizeof(*node_new));
-  if (list == NULL || node_new == NULL) {
+  struct linked_list_node *node_new = malloc(sizeof(struct linked_list_node));
+  if (node_new == NULL) {
+    perror("Error (linked_list_add_after_last)");
    exit(EXIT_FAILURE);
  }
  node_new->data = new_data;
@ -68,6 +83,7 @@ struct linked_list *linked_list_reverse(struct linked_list *list) {
    linked_list_add_after_last(linked_list_reversed, stack_node_current->data);
    stack_node_current = stack_node_current->next;
  }
+  stack_free(stack);
  return linked_list_reversed;
 }

@ -84,3 +100,14 @@ void linked_list_reverse_mutate(struct linked_list *list) {
    (*current) = temporary_current;
  }
 }
+
+void linked_list_free(struct linked_list *list) {
+  struct linked_list_node *node_current = list->head;
+  while (node_current != NULL) {
+    struct linked_list_node *node_to_remove = node_current;
+    node_current = node_current->next;
+    free(node_to_remove);
+  }
+  list->head = NULL;
+  free(list);
+}
--- a/lib/linked_list.h
+++ b/lib/linked_list.h
@ -1,32 +1,90 @@
-#ifndef __LINKED_LIST__
-#define __LINKED_LIST__
+#ifndef __LIBCPROJECT_LINKED_LIST__
+#define __LIBCPROJECT_LINKED_LIST__

+#include <errno.h>
 #include <stdbool.h>
 #include <stdlib.h>

 #include "stack.h"
+#include "types.h"

+/**
+ * @brief Linked list data structure.
+ * @since v1.0.0
+ */
 struct linked_list {
  struct linked_list_node *head;
-
  size_t length;
 };

+/**
+ * @brief Linked list node data structure.
+ * @since v1.0.0
+ */
 struct linked_list_node {
  void *data;
  struct linked_list_node *next;
 };

+/**
+ * @brief Linked list initialization.
+ *
+ * @return struct linked_list*
+ * @since v1.0.0
+ */
 struct linked_list *linked_list_initialization();

+/**
+ * @brief Add a new node in the head of the linked list.
+ *
+ * @param list
+ * @param new_value
+ * @return struct linked_list_node*
+ * @since v1.0.0
+ */
 struct linked_list_node *linked_list_add_in_head(struct linked_list *list, void *new_value);

+/**
+ * @brief Delete node in the head of the linked list.
+ *
+ * @param list
+ * @since v1.0.0
+ */
 void linked_list_delete_in_head(struct linked_list *list);

+/**
+ * @brief Add a new node in the tail of the linked list.
+ *
+ * @param list
+ * @param new_data
+ * @return struct linked_list_node*
+ * @since v1.0.0
+ */
 struct linked_list_node *linked_list_add_after_last(struct linked_list *list, void *new_data);

+/**
+ * @brief Reverse the linked list by creating a new one.
+ *
+ * @param list
+ * @return struct linked_list*
+ * @since v1.0.0
+ */
 struct linked_list *linked_list_reverse(struct linked_list *list);

+/**
+ * @brief Reverse the linked list by mutating it.
+ *
+ * @param list
+ * @since v1.0.0
+ */
 void linked_list_reverse_mutate(struct linked_list *list);

+/**
+ * @brief Frees the linked list.
+ *
+ * @param list
+ * @since v3.0.0
+ */
+void linked_list_free(struct linked_list *list);
+
 #endif
--- a/lib/mathematics.c
+++ b/lib/mathematics.c
@ -32,3 +32,39 @@ float mathematics_square_root(float number) {
 unsigned long long mathematics_factorial(unsigned long long number) {
  return number == 0 ? 1 : number * mathematics_factorial(number - 1);
 }
+
+int64_t mathematics_opposite(int64_t number) {
+  return number * -1;
+}
+
+int64_t mathematics_max(int64_t number1, int64_t number2) {
+  return number1 > number2 ? number1 : number2;
+}
+
+int64_t mathematics_max_values(int64_t *values, size_t values_length) {
+  int64_t max = 0;
+  if (values_length <= 0) {
+    return max;
+  }
+  max = values[0];
+  for (size_t index = 1; index < values_length; index++) {
+    max = mathematics_max(max, values[index]);
+  }
+  return max;
+}
+
+int64_t mathematics_min(int64_t number1, int64_t number2) {
+  return number1 > number2 ? number2 : number1;
+}
+
+int64_t mathematics_min_values(int64_t *values, size_t values_length) {
+  int64_t min = 0;
+  if (values_length <= 0) {
+    return min;
+  }
+  min = values[0];
+  for (size_t index = 1; index < values_length; index++) {
+    min = mathematics_min(min, values[index]);
+  }
+  return min;
+}
--- a/lib/mathematics.h
+++ b/lib/mathematics.h
@ -1,27 +1,125 @@
-#ifndef __MATHEMATICS__
-#define __MATHEMATICS__
+#ifndef __LIBCPROJECT_MATHEMATICS__
+#define __LIBCPROJECT_MATHEMATICS__

 #define MATHEMATICS_FLOAT_PRECISION 0.00000001

+#include <errno.h>
 #include <stdbool.h>
+#include <stdlib.h>

+#include "types.h"
+
+/**
+ * @brief Verify that 2 numbers are equal.
+ *
+ * @param number1
+ * @param number2
+ * @return true
+ * @return false
+ * @since v1.0.0
+ */
 bool mathematics_equals(const float number1, const float number2);

+/**
+ * @brief Get the absolute value of a number.
+ *
+ * @param number
+ * @return unsigned long long
+ * @since v1.0.0
+ */
 unsigned long long mathematics_absolute_value(const long long number);

+/**
+ * @brief Calculates the power of a number.
+ *
+ * @param base
+ * @param exponent
+ * @return unsigned long long
+ * @since v1.0.0
+ */
 unsigned long long mathematics_pow(unsigned long long base, unsigned long long exponent);

 /**
- * @brief Calculates the nth root of a number using Heron's method.
+ * @brief Calculates the nth root of a number.
 *
 * @param number
 * @param nth_root
 * @return float
+ * @since v1.0.0
 */
 float mathematics_root(float number, unsigned int nth_root);

+/**
+ * @brief Calculates the square root of a number using Heron's method.
+ *
+ * @param number
+ * @return float
+ * @since v1.0.0
+ */
 float mathematics_square_root(float number);

+/**
+ * @brief Calculates the factorial of a number.
+ *
+ * @param number
+ * @return unsigned long long
+ * @since v1.0.0
+ */
 unsigned long long mathematics_factorial(unsigned long long number);

+/**
+ * @brief Calulcates the opposite number (additive inverse).
+ *
+ * @param number
+ * @return int64_t
+ *
+ * @code
+ * mathematics_opposite(7) // -7
+ *
+ * mathematics_opposite(-7) // 7
+ * @endcode
+ * @since vTODO
+ */
+int64_t mathematics_opposite(int64_t number);
+
+/**
+ * @brief Returns the largest number between 2 numbers.
+ *
+ * @param number1
+ * @param number2
+ * @return int64_t
+ * @since vTODO
+ */
+int64_t mathematics_max(int64_t number1, int64_t number2);
+
+/**
+ * @brief Returns the largest number between multiple numbers. If the array is empty, returns 0.
+ *
+ * @param values
+ * @param values_length
+ * @return int64_t
+ * @since vTODO
+ */
+int64_t mathematics_max_values(int64_t *values, size_t values_length);
+
+/**
+ * @brief Returns the smallest number between 2 numbers.
+ *
+ * @param number1
+ * @param number2
+ * @return int64_t
+ * @since vTODO
+ */
+int64_t mathematics_min(int64_t number1, int64_t number2);
+
+/**
+ * @brief Returns the smallest number between multiple numbers. If the array is empty, returns 0.
+ *
+ * @param values
+ * @param values_length
+ * @return int64_t
+ * @since vTODO
+ */
+int64_t mathematics_min_values(int64_t *values, size_t values_length);
+
 #endif
--- a/lib/queue.c
+++ b/lib/queue.c
@ -1,8 +1,9 @@
 #include "queue.h"

 struct queue *queue_initialization() {
-  struct queue *queue = malloc(sizeof(*queue));
+  struct queue *queue = malloc(sizeof(struct queue));
  if (queue == NULL) {
+    perror("Error (queue_initialization)");
    exit(EXIT_FAILURE);
  }
  queue->first = NULL;
@ -11,8 +12,14 @@ struct queue *queue_initialization() {
 }

 void queue_push(struct queue *queue, void *data) {
-  struct queue_node *node_new = malloc(sizeof(*node_new));
-  if (queue == NULL || node_new == NULL) {
+  if (queue == NULL) {
+    errno = EINVAL;
+    perror("Error (queue_push)");
+    exit(EXIT_FAILURE);
+  }
+  struct queue_node *node_new = malloc(sizeof(struct queue_node));
+  if (node_new == NULL) {
+    perror("Error (queue_push)");
    exit(EXIT_FAILURE);
  }
  node_new->data = data;
@ -31,6 +38,8 @@ void queue_push(struct queue *queue, void *data) {

 void *queue_pop(struct queue *queue) {
  if (queue == NULL) {
+    errno = EINVAL;
+    perror("Error (queue_pop)");
    exit(EXIT_FAILURE);
  }
  struct queue_node *node = queue->first;
@ -43,3 +52,18 @@ void *queue_pop(struct queue *queue) {
  queue->length = queue->length - 1;
  return data;
 }
+
+void queue_free(struct queue *queue) {
+  if (queue == NULL) {
+    errno = EINVAL;
+    perror("Error (queue_free)");
+    exit(EXIT_FAILURE);
+  }
+  struct queue_node *node = queue->first;
+  while (node != NULL) {
+    struct queue_node *node_next = node->next;
+    free(node);
+    node = node_next;
+  }
+  free(queue);
+}
--- a/lib/queue.h
+++ b/lib/queue.h
@ -1,24 +1,62 @@
-#ifndef __QUEUE__
-#define __QUEUE__
+#ifndef __LIBCPROJECT_QUEUE__
+#define __LIBCPROJECT_QUEUE__

+#include <errno.h>
 #include <stdio.h>
 #include <stdlib.h>

-// FIFO = First In First Out
+#include "types.h"
+
+/**
+ * @brief Queue structure => FIFO (First In First Out).
+ * @since v1.0.0
+ */
 struct queue {
  struct queue_node *first;
  size_t length;
 };

+/**
+ * @brief Queue node structure.
+ * @since v1.0.0
+ */
 struct queue_node {
  void *data;
  struct queue_node *next;
 };

+/**
+ * @brief Queue initialization.
+ *
+ * @return struct queue*
+ * @since v1.0.0
+ */
 struct queue *queue_initialization();

+/**
+ * @brief Push data to queue.
+ *
+ * @param queue
+ * @param data
+ * @since v1.0.0
+ */
 void queue_push(struct queue *queue, void *data);

+/**
+ * @brief Pop data from queue.
+ *
+ * @param queue
+ * @return void*
+ * @since v1.0.0
+ */
 void *queue_pop(struct queue *queue);

+/**
+ * @brief Frees the queue.
+ *
+ * @param queue
+ * @since v3.0.0
+ */
+void queue_free(struct queue *queue);
+
 #endif
--- a/lib/stack.c
+++ b/lib/stack.c
@ -1,8 +1,9 @@
 #include "stack.h"

 struct stack *stack_initialization() {
-  struct stack *stack = malloc(sizeof(*stack));
+  struct stack *stack = malloc(sizeof(struct stack));
  if (stack == NULL) {
+    perror("Error (stack_initialization)");
    exit(EXIT_FAILURE);
  }
  stack->first = NULL;
@ -11,8 +12,14 @@ struct stack *stack_initialization() {
 }

 void stack_push(struct stack *stack, void *data) {
-  struct stack_node *node_new = malloc(sizeof(*node_new));
-  if (stack == NULL || data == NULL) {
+  if (stack == NULL) {
+    errno = EINVAL;
+    perror("Error (stack_push)");
+    exit(EXIT_FAILURE);
+  }
+  struct stack_node *node_new = malloc(sizeof(struct stack_node));
+  if (data == NULL) {
+    perror("Error (stack_push)");
    exit(EXIT_FAILURE);
  }
  node_new->data = data;
@ -23,6 +30,8 @@ void stack_push(struct stack *stack, void *data) {

 void *stack_pop(struct stack *stack) {
  if (stack == NULL) {
+    errno = EINVAL;
+    perror("Error (stack_pop)");
    exit(EXIT_FAILURE);
  }
  struct stack_node *node = stack->first;
@ -35,3 +44,18 @@ void *stack_pop(struct stack *stack) {
  stack->length = stack->length - 1;
  return data;
 }
+
+void stack_free(struct stack *stack) {
+  if (stack == NULL) {
+    errno = EINVAL;
+    perror("Error (stack_free)");
+    exit(EXIT_FAILURE);
+  }
+  struct stack_node *node = stack->first;
+  while (node != NULL) {
+    struct stack_node *node_next = node->next;
+    free(node);
+    node = node_next;
+  }
+  free(stack);
+}
--- a/lib/stack.h
+++ b/lib/stack.h
@ -1,24 +1,62 @@
-#ifndef __STACK__
-#define __STACK__
+#ifndef __LIBCPROJECT_STACK__
+#define __LIBCPROJECT_STACK__

+#include <errno.h>
 #include <stdio.h>
 #include <stdlib.h>

-// LIFO = Last In First Out
+#include "types.h"
+
+/**
+ * @brief Stack structure => LIFO (Last In First Out).
+ * @since v1.0.0
+ */
 struct stack {
  struct stack_node *first;
  size_t length;
 };

+/**
+ * @brief Stack node structure.
+ * @since v1.0.0
+ */
 struct stack_node {
  void *data;
  struct stack_node *next;
 };

+/**
+ * @brief Stack initialization.
+ *
+ * @return struct stack*
+ * @since v1.0.0
+ */
 struct stack *stack_initialization();

+/**
+ * @brief Push data to stack.
+ *
+ * @param stack
+ * @param data
+ * @since v1.0.0
+ */
 void stack_push(struct stack *stack, void *data);

+/**
+ * @brief Pop data from stack.
+ *
+ * @param stack
+ * @return void*
+ * @since v1.0.0
+ */
 void *stack_pop(struct stack *stack);

+/**
+ * @brief Frees the stack.
+ *
+ * @param stack
+ * @since v3.0.0
+ */
+void stack_free(struct stack *stack);
+
 #endif
--- a/lib/string.c
+++ b/lib/string.c
@ -1,6 +1,6 @@
 #include "string.h"

-size_t string_get_length(const char* string) {
+size_t string_get_length(const string_t string) {
  size_t length = 0;
  while (string[length] != '\0') {
    length++;
@ -8,107 +8,99 @@ size_t string_get_length(const char* string) {
  return length;
 }

-char* string_to_uppercase(char* string) {
+void string_to_uppercase(string_t string) {
  size_t string_length = string_get_length(string);
-  char* result = malloc(sizeof(char*) * string_length);
-  if (result == NULL) {
-    exit(EXIT_FAILURE);
-  }
  for (size_t index = 0; index < string_length; index++) {
-    character_append(result, character_to_upper(string[index]));
+    string[index] = character_to_upper(string[index]);
  }
-  return result;
+  string[string_length] = '\0';
 }

-char* string_to_lowercase(char* string) {
+void string_to_lowercase(string_t string) {
  size_t string_length = string_get_length(string);
-  char* result = malloc(sizeof(char*) * string_length);
-  if (result == NULL) {
-    exit(EXIT_FAILURE);
-  }
  for (size_t index = 0; index < string_length; index++) {
-    character_append(result, character_to_lower(string[index]));
+    string[index] = character_to_lower(string[index]);
  }
-  return result;
+  string[string_length] = '\0';
 }

-char* string_replace(char* string, char search, char replace) {
+void string_replace(string_t string, char search, char replace) {
  size_t string_length = string_get_length(string);
-  char* result = malloc(sizeof(char*) * string_length);
-  if (result == NULL) {
-    exit(EXIT_FAILURE);
-  }
  for (size_t index = 0; index < string_length; index++) {
    bool is_search_value = search == string[index];
    if (is_search_value) {
-      character_append(result, replace);
+      string[index] = replace;
    } else {
-      character_append(result, string[index]);
+      string[index] = string[index];
    }
  }
-  return result;
+  string[string_length] = '\0';
 }

-char* string_trim_start(char* string) {
+void string_remove_character(string_t string, char search) {
  size_t string_length = string_get_length(string);
-  char* result = malloc(sizeof(char*) * string_length);
-  if (result == NULL) {
-    exit(EXIT_FAILURE);
+  for (size_t index = 0; index < string_length; index++) {
+    if (string[index] == search) {
+      for (size_t index_string = index; index_string < string_length; index_string++) {
+        string[index_string] = string[index_string + 1];
+      }
+      string_length--;
+      index--;
+    }
  }
+  string[string_length] = '\0';
+}
+
+void string_trim_start(string_t string, char character) {
+  size_t string_length = string_get_length(string);
  size_t index_space = 0;
-  while (string[index_space] == ' ') {
+  while (string[index_space] == character) {
    index_space++;
  }
-  for (size_t index = index_space; index < string_length; index++) {
-    character_append(result, string[index]);
+  for (size_t index = 0; index < string_length - index_space; index++) {
+    string[index] = string[index + index_space];
  }
-  return result;
+  string[string_length - index_space] = '\0';
 }

-char* string_trim_end(char* string) {
+void string_trim_end(string_t string, char character) {
  size_t string_length = string_get_length(string);
-  char* result = malloc(sizeof(char*) * string_length);
-  if (result == NULL) {
-    exit(EXIT_FAILURE);
-  }
  size_t index_space = string_length - 1;
-  while (string[index_space] == ' ') {
+  while (string[index_space] == character) {
    index_space--;
  }
-  for (size_t index = 0; index < index_space + 1; index++) {
-    character_append(result, string[index]);
-  }
-  return result;
+  string[index_space + 1] = '\0';
 }

-char* string_trim(char* string) {
-  char* result = string_trim_start(string);
-  result = string_trim_end(result);
-  return result;
+void string_trim(string_t string, char character) {
+  string_trim_start(string, character);
+  string_trim_end(string, character);
 }

-char* string_copy(const char* string) {
-  return string_substring(string, 0, string_get_length(string));
-}
-
-char* string_capitalize(char* string) {
-  size_t string_length = string_get_length(string);
-  char* result = malloc(sizeof(char*) * string_length);
-  if (result == NULL) {
+string_t string_copy(const string_t string) {
+  size_t source_length = string_get_length(string);
+  string_t copy = malloc(sizeof(char) * (source_length + 1));
+  if (copy == NULL) {
+    perror("Error (string_copy)");
    exit(EXIT_FAILURE);
  }
-  for (size_t index = 0; index < string_length; index++) {
-    bool is_first_character = index == 0;
-    if (is_first_character) {
-      character_append(result, character_to_upper(string[index]));
-    } else {
-      character_append(result, string[index]);
-    }
+  size_t index;
+  for (index = 0; index < source_length; index++) {
+    copy[index] = string[index];
  }
-  return result;
+  copy[index] = '\0';
+  return copy;
 }

-size_t string_total_occurrences_of_character(char* string, char character) {
+void string_capitalize(string_t string) {
+  size_t string_length = string_get_length(string);
+  if (string_length == 0) {
+    return;
+  }
+  string[0] = character_to_upper(string[0]);
+}
+
+size_t string_total_occurrences_of_character(string_t string, char character) {
  size_t result = 0;
  size_t string_length = string_get_length(string);
  for (size_t index = 0; index < string_length; index++) {
@ -120,21 +112,20 @@ size_t string_total_occurrences_of_character(char* string, char character) {
  return result;
 }

-char* string_reverse(const char* string) {
+void string_reverse(const string_t string) {
  size_t string_length = string_get_length(string);
-  size_t index = 0;
-  char* result = malloc(sizeof(char*) * string_length);
-  if (result == NULL) {
-    exit(EXIT_FAILURE);
+  size_t index_start = 0;
+  size_t index_end = string_length - 1;
+  while (index_start < index_end) {
+    char temporary = string[index_start];
+    string[index_start] = string[index_end];
+    string[index_end] = temporary;
+    index_start++;
+    index_end--;
  }
-  for (index = string_length - 1; index > 0; index--) {
-    character_append(result, string[index]);
-  }
-  character_append(result, string[index]);
-  return result;
 }

-bool string_equals(const char* string1, const char* string2) {
+bool string_equals(const string_t string1, const string_t string2) {
  size_t string1_length = string_get_length(string1);
  size_t string2_length = string_get_length(string2);
  bool is_equal = string1_length == string2_length;
@ -146,7 +137,7 @@ bool string_equals(const char* string1, const char* string2) {
  return is_equal;
 }

-bool string_get_is_integer(const char* string) {
+bool string_get_is_integer(const string_t string) {
  size_t index = 0;
  size_t string_length = string_get_length(string);
  bool is_integer = string_length >= 1;
@ -166,106 +157,130 @@ bool string_get_is_integer(const char* string) {
  return is_integer;
 }

-char** string_split(const char* string, char separator, size_t* result_size) {
+string_t* string_split(const string_t string, char separator, size_t* result_size) {
  size_t string_length = string_get_length(string);
  size_t index_string = 0;
  size_t index_current = 0;
  size_t index_result = 0;
-  char* current = malloc(sizeof(char*) * string_length);
-  char** result = malloc(sizeof(char**) * index_result);
-  if (result == NULL || current == NULL) {
+  string_t current = malloc(sizeof(char) * (string_length + 1));
+  string_t* result = NULL;
+  if (current == NULL) {
+    perror("Error (string_split)");
    exit(EXIT_FAILURE);
  }
  while (index_string < string_length) {
    if (string[index_string] == separator) {
-      result[index_result] = string_copy(current);
-      index_result++;
-      result = realloc(result, sizeof(char*) * index_result);
+      current[index_current] = '\0';
+      result = realloc(result, sizeof(string_t) * (index_result + 1));
      if (result == NULL) {
+        perror("Error (string_split)");
        exit(EXIT_FAILURE);
      }
+      result[index_result] = string_copy(current);
+      index_result++;
      index_current = 0;
-      current = string_copy("");
    } else {
-      character_append(current, string[index_string]);
+      current[index_current] = string[index_string];
      index_current++;
    }
    index_string++;
  }
+  current[index_current] = '\0';
+  result = realloc(result, sizeof(string_t) * (index_result + 1));
+  if (result == NULL) {
+    perror("Error (string_split)");
+    exit(EXIT_FAILURE);
+  }
  result[index_result] = string_copy(current);
  free(current);
  *result_size = index_result + 1;
  return result;
 }

-char* string_join(char** array, const char separator, size_t array_length) {
-  size_t string_length = array_length;
-  char* string = malloc(sizeof(char*) * string_length);
+string_t string_join(string_t* array, const char separator, size_t array_length) {
+  size_t total_length = 0;
+  for (size_t index_array = 0; index_array < array_length; index_array++) {
+    total_length += string_get_length(array[index_array]);
+  }
+  size_t string_length = total_length + (array_length - 1);
+  string_t string = malloc(sizeof(char) * (string_length + 1));
  if (string == NULL) {
+    perror("Error (string_join)");
    exit(EXIT_FAILURE);
  }
+  size_t current_index = 0;
  for (size_t index_array = 0; index_array < array_length; index_array++) {
-    char* substring = array[index_array];
+    string_t substring = array[index_array];
    size_t substring_length = string_get_length(substring);
-    string_length += substring_length;
-    string = realloc(string, sizeof(char*) * string_length);
-    if (string == NULL) {
-      exit(EXIT_FAILURE);
-    }
    for (size_t index_substring = 0; index_substring < substring_length; index_substring++) {
-      character_append(string, substring[index_substring]);
+      string[current_index] = substring[index_substring];
+      current_index++;
    }
    bool is_last_character = index_array == (array_length - 1);
    if (!is_last_character) {
-      character_append(string, separator);
+      string[current_index] = separator;
+      current_index++;
    }
  }
+  string[string_length] = '\0';
  return string;
 }

-char* string_concatenate(char* string1, char* string2) {
-  size_t string1_length = string_get_length(string1);
-  size_t string2_length = string_get_length(string2);
-  size_t result_length = string1_length + string2_length;
-  char* result = malloc(sizeof(char*) * result_length);
-  if (result == NULL) {
+void string_concatenate(string_t* destination, string_t source) {
+  size_t destination_length = string_get_length(*destination);
+  size_t source_length = string_get_length(source);
+  size_t new_length = destination_length + source_length;
+  *destination = realloc(*destination, sizeof(char) * (new_length + 1));
+  if (*destination == NULL) {
+    perror("Error (string_concatenate)");
    exit(EXIT_FAILURE);
  }
-  for (size_t index_string1 = 0; index_string1 < string1_length; index_string1++) {
-    character_append(result, string1[index_string1]);
+  size_t index_destination = destination_length;
+  for (size_t index_source = 0; index_source < source_length; index_source++) {
+    (*destination)[index_destination++] = source[index_source];
  }
-  for (size_t index_string2 = 0; index_string2 < string2_length; index_string2++) {
-    character_append(result, string2[index_string2]);
-  }
-  return result;
+  (*destination)[index_destination] = '\0';
 }

-bool string_get_has_unique_characters(const char* string) {
+bool string_get_has_unique_characters(const string_t string) {
  bool has_unique = true;
  size_t string_length = string_get_length(string);
-  struct dictionary* characters_already_seen = dictionary_initialization();
+  struct hash_map* characters_already_seen = hash_map_initialization();
+  string_t* keys = malloc(sizeof(string_t) * string_length);
+  for (size_t index = 0; index < string_length; index++) {
+    keys[index] = NULL;
+  }
  for (size_t index = 0; index < string_length && has_unique; index++) {
    char character = string[index];
-    char* key = convert_character_to_string(character);
-    if (dictionary_contains_key(characters_already_seen, key)) {
+    keys[index] = convert_character_to_string(character);
+    string_t key = keys[index];
+    if (hash_map_contains_key(characters_already_seen, key)) {
      has_unique = false;
    } else {
-      dictionary_add(characters_already_seen, key, (void*)true);
+      hash_map_add(characters_already_seen, key, (void*)true);
    }
  }
+  for (size_t index = 0; index < string_length; index++) {
+    if (keys[index] != NULL) {
+      free(keys[index]);
+    }
+  }
+  free(keys);
+  hash_map_free(characters_already_seen);
  return has_unique;
 }

-char* string_substring(const char* string, size_t index_start, size_t index_end) {
-  size_t string_length = string_get_length(string);
-  char* result = malloc(sizeof(char*) * string_length);
-  for (size_t index = index_start; index <= index_end; index++) {
-    character_append(result, string[index]);
+string_t string_substring(const string_t string, size_t index_start, size_t index_end) {
+  size_t substring_length = index_end - index_start + 1;
+  string_t result = malloc(sizeof(char) * (substring_length + 1));
+  for (size_t index = 0; index < substring_length; index++) {
+    result[index] = string[index_start + index];
  }
+  result[substring_length] = '\0';
  return result;
 }

-bool string_get_is_substring(const char* string, const char* substring) {
+bool string_get_is_substring(const string_t string, const string_t substring) {
  bool is_substring = false;
  size_t string_length = string_get_length(string);
  size_t substring_length = string_get_length(substring);
@ -281,57 +296,73 @@ bool string_get_is_substring(const char* string, const char* substring) {
  return is_substring;
 }

-char* string_get_formatted_number(const long long number, char* separator) {
-  char* number_string = convert_number_to_string(number);
-  bool is_negative = number_string[0] == '-';
+string_t string_get_formatted_number(const long long number, string_t separator) {
+  string_t number_string_temp = convert_number_to_string(number);
+  string_t number_string = number_string_temp;
+  bool is_negative = number_string_temp[0] == '-';
  if (is_negative) {
-    number_string = string_substring(number_string, 1, string_get_length(number_string));
+    number_string = string_substring(number_string_temp, 1, string_get_length(number_string_temp));
+    free(number_string_temp);
  }
  size_t number_string_length = string_get_length(number_string);
-  char* result = malloc(sizeof(char*) * number_string_length);
+  size_t formatted_length = number_string_length + (number_string_length - 1) / 3;
+  string_t result = malloc(sizeof(char) * (formatted_length + 1));
  if (result == NULL) {
+    perror("Error (string_get_formatted_number)");
    exit(EXIT_FAILURE);
  }
  size_t count = 0;
+  size_t result_index = 0;
  for (size_t index = 0; index < number_string_length; index++) {
    size_t index_reversed = number_string_length - index - 1;
+    result[result_index] = number_string[index_reversed];
    count++;
-    result = string_concatenate(result, convert_character_to_string(number_string[index_reversed]));
-    if (count == 3) {
-      result = string_concatenate(result, separator);
+    result_index++;
+    if (count == 3 && index != number_string_length - 1) {
+      for (size_t sep_index = 0; sep_index < string_get_length(separator); sep_index++) {
+        result[result_index] = separator[sep_index];
+        result_index++;
+      }
      count = 0;
    }
  }
-  result = string_reverse(result);
-  size_t result_length = string_get_length(result);
-  if (result_length % 4 == 0) {
-    result = string_substring(result, 1, result_length);
-  }
+  free(number_string);
+  result[formatted_length] = '\0';
+  string_reverse(result);
  if (is_negative) {
-    result = string_concatenate(convert_character_to_string('-'), result);
+    string_t negative_result = convert_character_to_string('-');
+    string_concatenate(&negative_result, result);
+    free(result);
+    return negative_result;
  }
  return result;
 }

-char* string_get_last_occurence_of_character(const char* string, char character) {
+string_t string_get_last_occurence_of_character(const string_t string, char character) {
  size_t string_length = string_get_length(string);
-  char* result = malloc(sizeof(char*) * string_length);
+  size_t index_last_occurrence = SIZE_MAX;
+  for (size_t index = 0; index < string_length; index++) {
+    if (string[index] == character) {
+      index_last_occurrence = index;
+    }
+  }
+  if (index_last_occurrence == SIZE_MAX) {
+    return "";
+  }
+  string_t result = malloc(sizeof(char) * (string_length - index_last_occurrence + 1));
  if (result == NULL) {
+    perror("Error (string_get_last_occurence_of_character)");
    exit(EXIT_FAILURE);
  }
  size_t index_result = 0;
-  for (size_t index = 0; index < string_length; index++) {
-    if (string[index] == character) {
-      index_result = 0;
-      result = string_copy("");
-    }
-    character_append(result, string[index]);
-    index_result++;
+  for (size_t index = index_last_occurrence; index < string_length; index++) {
+    result[index_result++] = string[index];
  }
+  result[index_result] = '\0';
  return result;
 }

-bool string_starts_with(const char* string, const char* prefix) {
+bool string_starts_with(const string_t string, const string_t prefix) {
  bool starts_with = true;
  size_t prefix_length = string_get_length(prefix);
  for (size_t index = 0; index < prefix_length && starts_with; index++) {
@ -340,7 +371,7 @@ bool string_starts_with(const char* string, const char* prefix) {
  return starts_with;
 }

-bool string_ends_with(const char* string, const char* prefix) {
+bool string_ends_with(const string_t string, const string_t prefix) {
  bool ends_with = true;
  size_t string_length = string_get_length(string);
  size_t prefix_length = string_get_length(prefix);
@ -353,3 +384,59 @@ bool string_ends_with(const char* string, const char* prefix) {
  }
  return ends_with;
 }
+
+size_t string_position_of(const string_t string, const char character) {
+  size_t position_found = 0;
+  size_t string_length = string_get_length(string);
+  for (size_t index = 0; index < string_length && position_found == 0; index++) {
+    if (string[index] == character) {
+      position_found = index + 1;
+    }
+  }
+  return position_found;
+}
+
+size_t string_last_position_of(const string_t string, const char character) {
+  size_t position_found = 0;
+  size_t string_length = string_get_length(string);
+  while (string_length > 0 && position_found == 0) {
+    if (string[string_length - 1] == character) {
+      position_found = string_length;
+    }
+    string_length--;
+  }
+  return position_found;
+}
+
+string_t string_pad_start(const string_t string, const string_t pad_string, size_t target_length) {
+  string_t result = malloc(sizeof(char) * (target_length + 1));
+  size_t initial_length = string_get_length(string);
+  size_t left_length = target_length - initial_length;
+  if (target_length <= initial_length) {
+    left_length = 0;
+  }
+  size_t pad_length = string_get_length(pad_string);
+  size_t count_pad_string = 0;
+  size_t index_initial_string = 0;
+  for (size_t index = 0; index < target_length; index++) {
+    if (index < left_length) {
+      size_t index_pad_string = count_pad_string % pad_length;
+      result[index] = pad_string[index_pad_string];
+      count_pad_string += 1;
+    } else {
+      result[index] = string[index_initial_string];
+      index_initial_string += 1;
+    }
+  }
+  result[target_length] = '\0';
+  return result;
+}
+
+string_t string_zero_pad(uint64_t number, size_t places) {
+  string_t number_string = convert_number_to_string((long long)number);
+  string_t pad_string = string_copy("0");
+  string_t result = string_pad_start(number_string, pad_string, places);
+  free(pad_string);
+  free(number_string);
+  return result;
+}
--- a/lib/string.h
+++ b/lib/string.h
@ -1,87 +1,116 @@
-#ifndef __STRING__
-#define __STRING__
+#ifndef __LIBCPROJECT_STRING__
+#define __LIBCPROJECT_STRING__

+#include <errno.h>
 #include <stdbool.h>
 #include <stdio.h>
 #include <stdlib.h>

 #include "character.h"
 #include "convert.h"
-#include "dictionary.h"
+#include "hash_map.h"
+#include "types.h"

 /**
 * @brief Return the length of a string (excluding '\0').
 *
 * @param string
 * @return size_t
+ * @since v1.0.0
 */
-size_t string_get_length(const char* string);
+size_t string_get_length(const string_t string);

 /**
 * @brief Converts all the alphabetic characters in a string to uppercase.
 *
+ * NOTE: Mutates the string.
+ *
 * @param string
- * @return char*
+ * @since v1.0.0
 */
-char* string_to_uppercase(char* string);
+void string_to_uppercase(string_t string);

 /**
 * @brief Converts all the alphabetic characters in a string to lowercase.
 *
+ * NOTE: Mutates the string.
+ *
 * @param string
- * @return char*
+ * @since v1.0.0
 */
-char* string_to_lowercase(char* string);
+void string_to_lowercase(string_t string);

 /**
 * @brief Replace all the occurrences of search value into replace value in the string.
 *
- * @param string
- * @param search_value A character search value.
- * @param replace_value A character containing the text to replace for match.
- * @return char*
- */
-char* string_replace(char* string, char search, char replace);
-
-/**
- * @brief Removes all whitespace from the start of a string.
+ * NOTE: Mutates the string.
 *
 * @param string
- * @return char*
+ * @param search A character search value.
+ * @param replace A character containing the text to replace for match.
+ * @since v1.0.0
 */
-char* string_trim_start(char* string);
+void string_replace(string_t string, char search, char replace);

 /**
- * @brief Removes all whitespace from the end of a string.
+ * @brief Removes all the occurrences of a character in a string.
+ *
+ * NOTE: Mutates the string.
 *
 * @param string
- * @return char*
+ * @param search A character search value.
+ * @since v4.1.0
 */
-char* string_trim_end(char* string);
+void string_remove_character(string_t string, char search);

 /**
- * @brief Removes all whitespace from the start and end of a string.
+ * @brief Removes all `character` from the start of a string.
+ *
+ * NOTE: Mutates the string.
 *
 * @param string
- * @return char*
+ * @since v1.0.0
 */
-char* string_trim(char* string);
+void string_trim_start(string_t string, char character);
+
+/**
+ * @brief Removes all `character` from the end of a string.
+ *
+ * NOTE: Mutates the string.
+ *
+ * @param string
+ * @since v1.0.0
+ */
+void string_trim_end(string_t string, char character);
+
+/**
+ * @brief Removes all `character` from the start and end of a string.
+ *
+ * NOTE: Mutates the string.
+ *
+ * @param string
+ * @since v1.0.0
+ */
+void string_trim(string_t string, char character);

 /**
 * @brief Return the copy of a string.
 *
 * @param string
- * @return char*
+ * @return string_t
+ * @since v1.0.0
 */
-char* string_copy(const char* string);
+string_t string_copy(const string_t string);

 /**
 * @brief Capitalizes the string.
 *
+ * NOTE: Mutates the string.
+ *
 * @param string
- * @return char*
+ * @since v1.0.0
 */
-char* string_capitalize(char* string);
+void string_capitalize(string_t string);

 /**
 * @brief Returns the total number of occurrences of the given character in the string.
@ -89,68 +118,83 @@ char* string_capitalize(char* string);
 * @param string
 * @param character
 * @return size_t
+ * @since v1.0.0
 */
-size_t string_total_occurrences_of_character(char* string, char character);
+size_t string_total_occurrences_of_character(string_t string, char character);

 /**
- * @brief Reverse the characters in an array.
+ * @brief Reverse the characters in a string.
+ *
+ * NOTE: Mutates the string.
 *
 * @param string
- * @return char*
+ * @since v1.0.0
 */
-char* string_reverse(const char* string);
+void string_reverse(const string_t string);

 /**
 * @brief Check if two strings are equals.
 *
 * @param string1
 * @param string2
- * @return true if the strings are equals, false otherwise.
+ * @return true if the strings are equals.
+ * @return false if the strings are not equals.
+ * @since v1.0.0
 */
-bool string_equals(const char* string1, const char* string2);
+bool string_equals(const string_t string1, const string_t string2);

 /**
- * @brief Check if the string is a integer.
+ * @brief Check if the string is an integer.
 *
 * @param string
- * @return true if the string is a integer, false otherwise.
+ * @return true if the string is an integer.
+ * @return false if the string is not an integer.
+ * @since v1.0.0
 */
-bool string_get_is_integer(const char* string);
+bool string_get_is_integer(const string_t string);

 /**
 * @brief Split a string into substrings using the specified separator and return them as an array and update the pointer `result_size` to the resulting size of the created array.
 *
 * @param string
 * @param separator
- * @return char**
+ * @param result_size
+ * @return string_t*
+ * @since v1.0.0
 */
-char** string_split(const char* string, char separator, size_t* result_size);
+string_t* string_split(const string_t string, char separator, size_t* result_size);

 /**
 * @brief Adds all the elements of an array into a string, separated by the specified separator string.
 *
 * @param array
 * @param separator
- * @return char*
+ * @param array_length
+ * @return string_t
+ * @since v1.0.0
 */
-char* string_join(char** array, const char separator, size_t array_length);
+string_t string_join(string_t* array, const char separator, size_t array_length);

 /**
 * @brief Concatenate two strings.
 *
- * @param string1
- * @param string2
- * @return char*
+ * NOTE: Mutates the string `destination`.
+ *
+ * @param destination
+ * @param source
+ * @since v1.0.0
 */
-char* string_concatenate(char* string1, char* string2);
+void string_concatenate(string_t* destination, string_t source);

 /**
 * @brief Check if a string contains only unique characters.
 *
 * @param string
- * @return true if string contains only unique characters, false otherwise.
+ * @return true if string contains only unique characters.
+ * @return false if string contains duplicate characters.
+ * @since v1.0.0
 */
-bool string_get_has_unique_characters(const char* string);
+bool string_get_has_unique_characters(const string_t string);

 /**
 * @brief Returns the part of the string between the start and end indexes (both included).
@ -158,52 +202,126 @@ bool string_get_has_unique_characters(const char* string);
 * @param string
 * @param index_start
 * @param index_end
- * @return char*
+ * @return string_t
+ * @since v1.0.0
 */
-char* string_substring(const char* string, size_t index_start, size_t index_end);
+string_t string_substring(const string_t string, size_t index_start, size_t index_end);

 /**
 * @brief Check if a string contains a substring.
 *
 * @param string
 * @param substring
- * @return true if the string contains the substring, false otherwise.
+ * @return true if the string contains the substring.
+ * @return false if the string does not contain the substring.
+ * @since v1.0.0
 */
-bool string_get_is_substring(const char* string, const char* substring);
+bool string_get_is_substring(const string_t string, const string_t substring);

 /**
 * @brief Format a number to a string with specified separator.
 *
- * @param integer
- * @return char* example: string_get_formatted_number(1000, " ") => "1 000"
+ * @param number
+ * @param separator
+ * @return string_t
+ *
+ * @code
+ * string_get_formatted_number(1000, " ") // "1 000"
+ * string_get_formatted_number(1000, ",") // "1,000"
+ * @endcode
+ * @since v1.0.0
 */
-char* string_get_formatted_number(const long long number, char* separator);
+string_t string_get_formatted_number(const long long number, string_t separator);

 /**
 * @brief Returns a pointer to the last occurrence of character in the string.
 *
 * @param string
 * @param character
- * @return char*
+ * @return string_t
+ * @since v1.0.0
 */
-char* string_get_last_occurence_of_character(const char* string, char character);
+string_t string_get_last_occurence_of_character(const string_t string, char character);

 /**
 * @brief Check if a string starts with a substring.
 *
 * @param string
 * @param prefix
- * @return true if the string starts with the substring, false otherwise.
+ * @return true if the string starts with the substring.
+ * @return false if the string does not start with the substring.
+ * @since v1.0.0
 */
-bool string_starts_with(const char* string, const char* prefix);
+bool string_starts_with(const string_t string, const string_t prefix);

 /**
 * @brief Check if a string ends with a substring.
 *
 * @param string
 * @param prefix
- * @return true if the string ends with the substring, false otherwise.
+ * @return true if the string ends with the substring.
+ * @return false if the string does not end with the substring.
+ * @since v1.0.0
 */
-bool string_ends_with(const char* string, const char* prefix);
+bool string_ends_with(const string_t string, const string_t prefix);
+
+/**
+ * @brief Returns the position (index + 1) within the string of the first occurrence of the specified substring (0 if not found).
+ *
+ * @param string
+ * @param substring
+ * @return size_t
+ *
+ * @code
+ * string_position_of("hello world", 'e') // 2
+ * @endcode
+ * @since v4.2.0
+ */
+size_t string_position_of(const string_t string, const char character);
+
+/**
+ * @brief Returns the position (index + 1) within the string of the last occurrence of the specified substring (0 if not found).
+ *
+ * @param string
+ * @param character
+ * @return size_t
+ *
+ * @code
+ * string_last_position_of("hello world", 'o') // 8
+ * @endcode
+ * @since v4.2.0
+ */
+size_t string_last_position_of(const string_t string, const char character);
+
+/**
+ * @brief Pads a `string` with another `pad_string` (multiple times, if needed) until the resulting string reaches the `target_length`. The padding is applied from the start (left) of the string.
+ *
+ * @param string The string to pad.
+ * @param pad_string The string to pad the current string with, to the left.
+ * @param target_length
+ * @return string_t
+ *
+ * @code
+ * string_pad_start("hello", " ", 10) // "     hello"
+ * @endcode
+ * @since vTODO
+ */
+string_t string_pad_start(const string_t string, const string_t pad_string, size_t target_length);
+
+/**
+ * @brief Pad a number with zeros.
+ *
+ * @param number
+ * @param places
+ * @return string_t
+ *
+ * @code
+ * string_zero_pad(1, 2) // "01"
+ *
+ * string_zero_pad(10, 2) // "10"
+ * @endcode
+ * @since vTODO
+ */
+string_t string_zero_pad(uint64_t number, size_t places);

 #endif
--- a/lib/terminal.c
+++ b/lib/terminal.c
@ -1,10 +1,11 @@
 #include "terminal.h"

-char* terminal_input() {
+string_t terminal_input() {
  char character;
  size_t length = 1;
-  char* string = malloc(length * sizeof(char));
+  string_t string = malloc(length * sizeof(char));
  if (string == NULL) {
+    perror("Error (terminal_input)");
    exit(EXIT_FAILURE);
  }
  *string = '\0';
@ -12,6 +13,7 @@ char* terminal_input() {
    length++;
    string = realloc(string, length * sizeof(char));
    if (string == NULL) {
+      perror("Error (terminal_input)");
      exit(EXIT_FAILURE);
    }
    character_append(string, character);
@ -22,7 +24,7 @@ char* terminal_input() {
 void terminal_print_array(void* array, size_t array_size, size_t element_size, void (*print_element)(void*)) {
  printf("[");
  for (size_t index = 0; index < array_size; index++) {
-    void* element = (char*)array + index * element_size;
+    void* element = (string_t)array + index * element_size;
    print_element(element);
    bool is_last = index == array_size - 1;
    if (!is_last) {
@ -45,21 +47,23 @@ void terminal_print_unsigned_long(void* value) {
 }

 void terminal_print_char(void* value) {
-  printf("%c", *(char*)value);
+  printf("%c", *(string_t)value);
 }

 void terminal_print_string(void* value) {
-  printf("%s", (char*)value);
+  printf("%s", (string_t)value);
 }

 void terminal_print_stack(struct stack* stack, void (*print_element)(void*)) {
  if (stack == NULL) {
+    errno = EINVAL;
+    perror("Error (terminal_print_stack)");
    exit(EXIT_FAILURE);
  }
  struct stack_node* node_current = stack->first;
  while (node_current != NULL) {
    printf("|\t");
-    void* element = (char*)node_current->data;
+    void* element = node_current->data;
    print_element(&element);
    node_current = node_current->next;
    printf("\t|\n");
@ -68,12 +72,14 @@ void terminal_print_stack(struct stack* stack, void (*print_element)(void*)) {

 void terminal_print_queue(struct queue* queue, void (*print_element)(void*)) {
  if (queue == NULL) {
+    errno = EINVAL;
+    perror("Error (terminal_print_queue)");
    exit(EXIT_FAILURE);
  }
  struct queue_node* node_current = queue->first;
  while (node_current != NULL) {
    printf("|\t");
-    void* element = (char*)node_current->data;
+    void* element = node_current->data;
    print_element(&element);
    node_current = node_current->next;
    printf("\t|\n");
@ -82,11 +88,13 @@ void terminal_print_queue(struct queue* queue, void (*print_element)(void*)) {

 void terminal_print_linked_list(struct linked_list* linked_list, void (*print_element)(void*)) {
  if (linked_list == NULL) {
+    errno = EINVAL;
+    perror("Error (terminal_print_linked_list)");
    exit(EXIT_FAILURE);
  }
  struct linked_list_node* node_current = linked_list->head;
  while (node_current != NULL) {
-    void* element = (char*)node_current->data;
+    void* element = (string_t)node_current->data;
    node_current = node_current->next;
    print_element(&element);
    printf(" -> ");
@ -94,18 +102,26 @@ void terminal_print_linked_list(struct linked_list* linked_list, void (*print_el
  printf("NULL\n");
 }

-void terminal_print_dictionary(struct dictionary* dictionary, void (*print_element)(void*)) {
-  if (dictionary == NULL) {
+void terminal_print_hash_map(struct hash_map* hash_map, void (*print_element)(void*)) {
+  if (hash_map == NULL) {
+    errno = EINVAL;
+    perror("Error (terminal_print_hash_map)");
    exit(EXIT_FAILURE);
  }
  printf("{\n");
-  for (size_t index = 0; index < dictionary->length; index++) {
-    struct dictionary_item* item = dictionary->items[index];
+  string_t* keys = hash_map_get_keys(hash_map);
+  for (size_t index = 0; index < hash_map->length; index++) {
+    string_t key = keys[index];
+    void* value = hash_map_get(hash_map, key);
    printf("\t\"");
-    terminal_print_string(item->key);
+    terminal_print_string(key);
    printf("\" -> ");
-    print_element(&item->data);
+    print_element(&value);
    printf("\n");
  }
  printf("}\n");
 }
+
+void terminal_print_array_list(struct array_list* list, void (*print_element)(void*)) {
+  terminal_print_array(list->data, list->size, sizeof(void*), print_element);
+}
--- a/lib/terminal.h
+++ b/lib/terminal.h
@ -1,42 +1,122 @@
-#ifndef __TERMINAL__
-#define __TERMINAL__
+#ifndef __LIBCPROJECT_TERMINAL__
+#define __LIBCPROJECT_TERMINAL__

+#include <errno.h>
 #include <stdbool.h>
 #include <stdint.h>
 #include <stdio.h>
 #include <stdlib.h>

+#include "array_list.h"
 #include "character.h"
-#include "dictionary.h"
+#include "hash_map.h"
 #include "linked_list.h"
 #include "queue.h"
 #include "stack.h"
+#include "types.h"

 /**
 * @brief Read a line from stdin.
 *
- * @return char*
+ * @return string_t
+ * @since v1.0.0
 */
-char* terminal_input();
+string_t terminal_input();

+/**
+ * @brief Print an array.
+ *
+ * @param array
+ * @param array_size
+ * @param element_size
+ * @param print_element
+ * @since v1.0.0
+ */
 void terminal_print_array(void* array, size_t array_size, size_t element_size, void (*print_element)(void*));

+/**
+ * @brief Print a int.
+ *
+ * @param value
+ * @since v1.0.0
+ */
 void terminal_print_int(void* value);

+/**
+ * @brief Print a long.
+ *
+ * @param value
+ * @since v1.0.0
+ */
 void terminal_print_long(void* value);

+/**
+ * @brief Print a unsigned long.
+ *
+ * @param value
+ * @since v1.0.0
+ */
 void terminal_print_unsigned_long(void* value);

+/**
+ * @brief Print a char.
+ *
+ * @param value
+ * @since v1.0.0
+ */
 void terminal_print_char(void* value);

+/**
+ * @brief Print a string.
+ *
+ * @param value
+ * @since v1.0.0
+ */
 void terminal_print_string(void* value);

+/**
+ * @brief Print a stack.
+ *
+ * @param stack
+ * @param print_element
+ * @since v1.0.0
+ */
 void terminal_print_stack(struct stack* stack, void (*print_element)(void*));

+/**
+ * @brief Print a queue.
+ *
+ * @param queue
+ * @param print_element
+ * @since v1.0.0
+ */
 void terminal_print_queue(struct queue* queue, void (*print_element)(void*));

+/**
+ * @brief Print a linked list.
+ *
+ * @param linked_list
+ * @param print_element
+ * @since v1.0.0
+ */
 void terminal_print_linked_list(struct linked_list* linked_list, void (*print_element)(void*));

-void terminal_print_dictionary(struct dictionary* dictionary, void (*print_element)(void*));
+/**
+ * @brief Print a hash map.
+ *
+ * @param hash_map
+ * @param print_element
+ * @since v2.0.0
+ */
+void terminal_print_hash_map(struct hash_map* hash_map, void (*print_element)(void*));
+
+/**
+ * @brief Print an array list.
+ *
+ * @param list
+ * @param print_element
+ * @since v3.0.0
+ */
+void terminal_print_array_list(struct array_list* list, void (*print_element)(void*));

 #endif
--- a/lib/types.h
+++ b/lib/types.h
@ -0,0 +1,10 @@
+#ifndef __LIBCPROJECT_TYPES__
+#define __LIBCPROJECT_TYPES__
+
+#include <stdint.h>
+
+typedef uint8_t byte_t;
+
+typedef char* string_t;
+
+#endif
--- a/libcproject.h
+++ b/libcproject.h
@ -4,14 +4,15 @@
 #include "lib/array_list.h"
 #include "lib/character.h"
 #include "lib/convert.h"
-#include "lib/dictionary.h"
 #include "lib/filesystem.h"
+#include "lib/hash_map.h"
 #include "lib/linked_list.h"
 #include "lib/mathematics.h"
 #include "lib/queue.h"
 #include "lib/stack.h"
 #include "lib/string.h"
 #include "lib/terminal.h"
+#include "lib/types.h"
 #include "version.h"

 #endif
--- a/main.c
+++ b/main.c
@ -4,7 +4,7 @@
 #include "libcproject.h"

 int main() {
-  char* string = "Hello, world!";
+  string_t string = "Hello, world!";
  printf("%s\n", string);
  printf("string_length = %ld\n", string_get_length(string));
  return EXIT_SUCCESS;
--- a/set_version.c
+++ b/set_version.c
@ -3,21 +3,23 @@

 #include "libcproject.h"

-int main(int argc, char* argv[]) {
+int main(int argc, string_t* argv) {
  if (argc != 2) {
    fprintf(stderr, "Usage: %s <version>\n", argv[0]);
    return EXIT_FAILURE;
  }
-  char* content = "#ifndef __LIBCPROJECT_VERSION__\n";
-  content = string_concatenate(content, "#define __LIBCPROJECT_VERSION__ \"");
-  content = string_concatenate(content, argv[1]);
-  content = string_concatenate(content, "\"\n\n");
-  content = string_concatenate(content, "#endif\n");
-  int result = filesystem_write("./version.h", content, string_get_length(content));
+  string_t content = string_copy("#ifndef __LIBCPROJECT_VERSION__\n");
+  string_concatenate(&content, "#define __LIBCPROJECT_VERSION__ \"");
+  string_concatenate(&content, argv[1]);
+  string_concatenate(&content, "\"\n\n");
+  string_concatenate(&content, "#endif\n");
+  int result = filesystem_write("./version.h", (byte_t*)content, string_get_length(content));
  if (result == -1) {
    fprintf(stderr, "Error: Could not write to file.\n");
+    perror("Error (set_version)");
    return EXIT_FAILURE;
  }
  printf("Success: Version set to %s.\n", argv[1]);
+  free(content);
  return EXIT_SUCCESS;
 }
--- a/test/array_list_test.c
+++ b/test/array_list_test.c
@ -32,4 +32,17 @@ void array_list_test() {
  array_list_remove(list, 100);
  assert(list->size == 105);
  assert(array_list_get(list, 100) == (void *)95);
+
+  array_list_free(list);
+
+  list = array_list_initialization();
+  array_list_add(list, (void *)'a');
+  array_list_add(list, (void *)'b');
+  array_list_add(list, (void *)'c');
+  array_list_remove(list, 1);
+  assert(array_list_get(list, 0) == (void *)'a');
+  assert(array_list_get(list, 1) == (void *)'c');
+  assert(list->size == 2);
+
+  array_list_free(list);
 }
--- a/test/character_test.c
+++ b/test/character_test.c
@ -20,7 +20,7 @@ void character_append_at_test() {
  character_append_at(string, 'd', 1);
  assert(assert_string_equal(string, "adbc"));

-  char string2[5] = "abcd";
+  char string2[6] = "abcd";
  character_append_at(string2, 'e', 4);
  assert(assert_string_equal(string2, "abcde"));
 }
--- a/test/convert_test.c
+++ b/test/convert_test.c
@ -10,11 +10,25 @@ void convert_test() {
 }

 void convert_character_to_string_test() {
-  assert(assert_string_equal(convert_character_to_string('a'), "a"));
-  assert(assert_string_equal(convert_character_to_string('A'), "A"));
-  assert(assert_string_equal(convert_character_to_string('0'), "0"));
-  assert(assert_string_equal(convert_character_to_string(' '), " "));
-  assert(assert_string_equal(convert_character_to_string('\0'), ""));
+  string_t result = convert_character_to_string('a');
+  assert(assert_string_equal(result, "a"));
+  free(result);
+
+  result = convert_character_to_string('A');
+  assert(assert_string_equal(result, "A"));
+  free(result);
+
+  result = convert_character_to_string('0');
+  assert(assert_string_equal(result, "0"));
+  free(result);
+
+  result = convert_character_to_string(' ');
+  assert(assert_string_equal(result, " "));
+  free(result);
+
+  result = convert_character_to_string('\0');
+  assert(assert_string_equal(result, ""));
+  free(result);
 }

 void convert_character_to_digit_test() {
@ -63,33 +77,109 @@ void convert_string_to_number_test() {
 }

 void convert_number_to_string_test() {
-  assert(assert_string_equal(convert_number_to_string(0), "0"));
-  assert(assert_string_equal(convert_number_to_string(1), "1"));
-  assert(assert_string_equal(convert_number_to_string(2), "2"));
-  assert(assert_string_equal(convert_number_to_string(3), "3"));
-  assert(assert_string_equal(convert_number_to_string(4), "4"));
-  assert(assert_string_equal(convert_number_to_string(5), "5"));
-  assert(assert_string_equal(convert_number_to_string(6), "6"));
-  assert(assert_string_equal(convert_number_to_string(7), "7"));
-  assert(assert_string_equal(convert_number_to_string(8), "8"));
-  assert(assert_string_equal(convert_number_to_string(9), "9"));
-  assert(assert_string_equal(convert_number_to_string(10), "10"));
-  assert(assert_string_equal(convert_number_to_string(11), "11"));
-  assert(assert_string_equal(convert_number_to_string(20), "20"));
-  assert(assert_string_equal(convert_number_to_string(-0), "0"));
-  assert(assert_string_equal(convert_number_to_string(-1), "-1"));
-  assert(assert_string_equal(convert_number_to_string(-20), "-20"));
+  string_t result = convert_number_to_string(0);
+  assert(assert_string_equal(result, "0"));
+  free(result);
+
+  result = convert_number_to_string(1);
+  assert(assert_string_equal(result, "1"));
+  free(result);
+
+  result = convert_number_to_string(2);
+  assert(assert_string_equal(result, "2"));
+  free(result);
+
+  result = convert_number_to_string(3);
+  assert(assert_string_equal(result, "3"));
+  free(result);
+
+  result = convert_number_to_string(4);
+  assert(assert_string_equal(result, "4"));
+  free(result);
+
+  result = convert_number_to_string(5);
+  assert(assert_string_equal(result, "5"));
+  free(result);
+
+  result = convert_number_to_string(6);
+  assert(assert_string_equal(result, "6"));
+  free(result);
+
+  result = convert_number_to_string(7);
+  assert(assert_string_equal(result, "7"));
+  free(result);
+
+  result = convert_number_to_string(8);
+  assert(assert_string_equal(result, "8"));
+  free(result);
+
+  result = convert_number_to_string(9);
+  assert(assert_string_equal(result, "9"));
+  free(result);
+
+  result = convert_number_to_string(10);
+  assert(assert_string_equal(result, "10"));
+  free(result);
+
+  result = convert_number_to_string(11);
+  assert(assert_string_equal(result, "11"));
+  free(result);
+
+  result = convert_number_to_string(20);
+  assert(assert_string_equal(result, "20"));
+  free(result);
+
+  result = convert_number_to_string(-0);
+  assert(assert_string_equal(result, "0"));
+  free(result);
+
+  result = convert_number_to_string(-1);
+  assert(assert_string_equal(result, "-1"));
+  free(result);
+
+  result = convert_number_to_string(-20);
+  assert(assert_string_equal(result, "-20"));
+  free(result);
 }

 void convert_number_from_base_to_another_test() {
-  assert(assert_string_equal(convert_number_from_base_to_another("15", 10, 16), "F"));
-  assert(assert_string_equal(convert_number_from_base_to_another("100000000", 2, 16), "100"));
-  assert(assert_string_equal(convert_number_from_base_to_another("FFFFFF", 16, 10), "16777215"));
-  assert(assert_string_equal(convert_number_from_base_to_another("1D57", 17, 35), "75C"));
-  assert(assert_string_equal(convert_number_from_base_to_another("80E", 20, 5), "100324"));
-  assert(assert_string_equal(convert_number_from_base_to_another("99", 10, 10), "99"));
-  assert(assert_string_equal(convert_number_from_base_to_another("3433024", 6, 28), "8008"));
-  assert(assert_string_equal(convert_number_from_base_to_another("30288G3A", 17, 36), "KF12OI"));
-  assert(assert_string_equal(convert_number_from_base_to_another("10", 9, 9), "10"));
-  assert(assert_string_equal(convert_number_from_base_to_another("10E", 23, 8), "1037"));
+  string_t result = convert_number_from_base_to_another("15", 10, 16);
+  assert(assert_string_equal(result, "F"));
+  free(result);
+
+  result = convert_number_from_base_to_another("100000000", 2, 16);
+  assert(assert_string_equal(result, "100"));
+  free(result);
+
+  result = convert_number_from_base_to_another("FFFFFF", 16, 10);
+  assert(assert_string_equal(result, "16777215"));
+  free(result);
+
+  result = convert_number_from_base_to_another("1D57", 17, 35);
+  assert(assert_string_equal(result, "75C"));
+  free(result);
+
+  result = convert_number_from_base_to_another("80E", 20, 5);
+  assert(assert_string_equal(result, "100324"));
+  free(result);
+
+  result = convert_number_from_base_to_another("99", 10, 10);
+  assert(assert_string_equal(result, "99"));
+  free(result);
+
+  result = convert_number_from_base_to_another("3433024", 6, 28);
+  assert(assert_string_equal(result, "8008"));
+  free(result);
+
+  result = convert_number_from_base_to_another("30288G3A", 17, 36);
+  assert(assert_string_equal(result, "KF12OI"));
+  free(result);
+
+  result = convert_number_from_base_to_another("10", 9, 9);
+  assert(assert_string_equal(result, "10"));
+  free(result);
+
+  result = convert_number_from_base_to_another("10E", 23, 8);
+  assert(assert_string_equal(result, "1037"));
+  free(result);
 }
--- a/test/dictionary_test.c
+++ b/test/dictionary_test.c
@ -1,27 +0,0 @@
-#include "dictionary_test.h"
-
-void dictionary_test() {
-  struct dictionary *dictionary = dictionary_initialization();
-  assert(dictionary->length == 0);
-  dictionary_add(dictionary, "key", (void *)'a');
-  dictionary_add(dictionary, "key1", (void *)'b');
-  dictionary_add(dictionary, "key2", (void *)'c');
-  dictionary_add(dictionary, "key3", (void *)'d');
-  dictionary_add(dictionary, "key4", (void *)'e');
-  dictionary_add(dictionary, "key5", (void *)'f');
-  assert(dictionary->length == 6);
-  assert(dictionary_get(dictionary, "key")->data == (void *)'a');
-  assert(dictionary_get(dictionary, "key1")->data == (void *)'b');
-  assert(dictionary_get(dictionary, "key2")->data == (void *)'c');
-  assert(dictionary_get(dictionary, "key3")->data == (void *)'d');
-  assert(dictionary_get(dictionary, "key4")->data == (void *)'e');
-  assert(dictionary_get(dictionary, "key5")->data == (void *)'f');
-  dictionary_add(dictionary, "key5", (void *)'a');
-  assert(dictionary_get(dictionary, "key5")->data == (void *)'a');
-  assert(dictionary_contains_key(dictionary, "key5"));
-  assert(!dictionary_contains_key(dictionary, "invalid key"));
-  assert(dictionary_contains_key(dictionary, "key5"));
-  dictionary_remove(dictionary, "key5");
-  assert(dictionary->length == 5);
-  assert(!dictionary_contains_key(dictionary, "key5"));
-}
--- a/test/hash_map_test.c
+++ b/test/hash_map_test.c
@ -0,0 +1,28 @@
+#include "hash_map_test.h"
+
+void hash_map_test() {
+  struct hash_map *hash_map = hash_map_initialization();
+  assert(hash_map->length == 0);
+  hash_map_add(hash_map, "key", (void *)'a');
+  hash_map_add(hash_map, "key1", (void *)'b');
+  hash_map_add(hash_map, "key2", (void *)'c');
+  hash_map_add(hash_map, "key3", (void *)'d');
+  hash_map_add(hash_map, "key4", (void *)'e');
+  hash_map_add(hash_map, "key5", (void *)'f');
+  assert(hash_map->length == 6);
+  assert(hash_map_get(hash_map, "key") == (void *)'a');
+  assert(hash_map_get(hash_map, "key1") == (void *)'b');
+  assert(hash_map_get(hash_map, "key2") == (void *)'c');
+  assert(hash_map_get(hash_map, "key3") == (void *)'d');
+  assert(hash_map_get(hash_map, "key4") == (void *)'e');
+  assert(hash_map_get(hash_map, "key5") == (void *)'f');
+  hash_map_add(hash_map, "key5", (void *)'a');
+  assert(hash_map_get(hash_map, "key5") == (void *)'a');
+  assert(hash_map_contains_key(hash_map, "key5"));
+  assert(!hash_map_contains_key(hash_map, "invalid key"));
+  assert(hash_map_contains_key(hash_map, "key5"));
+  hash_map_remove(hash_map, "key5");
+  assert(hash_map->length == 5);
+  assert(!hash_map_contains_key(hash_map, "key5"));
+  hash_map_free(hash_map);
+}
--- a/test/dictionary_test.h
+++ b/test/dictionary_test.h
@ -1,5 +1,5 @@
-#ifndef __DICTIONARY_TEST__
-#define __DICTIONARY_TEST__
+#ifndef __HASH_MAP_TEST__
+#define __HASH_MAP_TEST__

 #include <assert.h>
 #include <stdio.h>
@ -7,6 +7,6 @@

 #include "libcproject.h"

-void dictionary_test();
+void hash_map_test();

 #endif
--- a/test/linked_list_test.c
+++ b/test/linked_list_test.c
@ -13,6 +13,7 @@ void linked_list_initialization_test() {
  struct linked_list *list = linked_list_initialization();
  assert(list->length == 0);
  assert(list->head == NULL);
+  linked_list_free(list);
 }

 void linked_list_add_in_head_test() {
@ -25,6 +26,7 @@ void linked_list_add_in_head_test() {
  assert(((uintptr_t)list->head->next->data) == 8);
  assert(((uintptr_t)list->head->next->next->data) == 4);
  assert(list->head->next->next->next == NULL);
+  linked_list_free(list);
 }

 void linked_list_delete_in_head_test() {
@ -37,6 +39,7 @@ void linked_list_delete_in_head_test() {
  assert(((uintptr_t)list->head->data) == 8);
  assert(((uintptr_t)list->head->next->data) == 4);
  assert(list->head->next->next == NULL);
+  linked_list_free(list);
 }

 void linked_list_add_after_last_test() {
@ -54,6 +57,7 @@ void linked_list_add_after_last_test() {
  assert(((uintptr_t)list->head->next->data) == 8);
  assert(((uintptr_t)list->head->next->next->data) == 4);
  assert(((uintptr_t)list->head->next->next->next->data) == 18);
+  linked_list_free(list);
 }

 void linked_list_reverse_test() {
@ -74,6 +78,8 @@ void linked_list_reverse_test() {
  assert((list_reversed->head->next->data) == (void *)'C');
  assert((list_reversed->head->next->next->data) == (void *)'B');
  assert((list_reversed->head->next->next->next->data) == (void *)'A');
+  linked_list_free(list);
+  linked_list_free(list_reversed);
 }

 void linked_list_reverse_mutate_test() {
@ -89,4 +95,5 @@ void linked_list_reverse_mutate_test() {
  assert((list->head->next->data) == (void *)'C');
  assert((list->head->next->next->data) == (void *)'B');
  assert((list->head->next->next->next->data) == (void *)'A');
+  linked_list_free(list);
 }
--- a/test/main.c
+++ b/test/main.c
@ -4,7 +4,7 @@
 #include "array_list_test.h"
 #include "character_test.h"
 #include "convert_test.h"
-#include "dictionary_test.h"
+#include "hash_map_test.h"
 #include "linked_list_test.h"
 #include "mathematics_test.h"
 #include "queue_test.h"
@ -15,7 +15,7 @@ int main() {
  array_list_test();
  character_test();
  convert_test();
-  dictionary_test();
+  hash_map_test();
  linked_list_test();
  mathematics_test();
  queue_test();
--- a/test/mathematics_test.c
+++ b/test/mathematics_test.c
@ -6,6 +6,11 @@ void mathematics_test() {
  mathematics_root_test();
  mathematics_square_root_test();
  mathematics_factorial_test();
+  mathematics_opposite_test();
+  mathematics_max_test();
+  mathematics_max_values_test();
+  mathematics_min_test();
+  mathematics_min_values_test();
 }

 void mathematics_absolute_value_test() {
@ -56,3 +61,38 @@ void mathematics_factorial_test() {
  assert(mathematics_factorial(9) == 362880);
  assert(mathematics_factorial(10) == 3628800);
 }
+
+void mathematics_opposite_test() {
+  assert(mathematics_opposite(-7) == 7);
+  assert(mathematics_opposite(7) == -7);
+}
+
+void mathematics_max_test() {
+  assert(mathematics_max(0, 0) == 0);
+  assert(mathematics_max(0, 1) == 1);
+  assert(mathematics_max(2, 0) == 2);
+  assert(mathematics_max(54, 37) == 54);
+}
+
+void mathematics_max_values_test() {
+  int64_t values[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
+  assert(mathematics_max_values(values, 10) == 9);
+
+  int64_t values2[] = {8, 6, 4, 7};
+  assert(mathematics_max_values(values2, 4) == 8);
+}
+
+void mathematics_min_test() {
+  assert(mathematics_min(0, 0) == 0);
+  assert(mathematics_min(3, 5) == 3);
+  assert(mathematics_min(2, 1) == 1);
+  assert(mathematics_min(54, 37) == 37);
+}
+
+void mathematics_min_values_test() {
+  int64_t values[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
+  assert(mathematics_min_values(values, 10) == 0);
+
+  int64_t values2[] = {9, 6, 8, 7};
+  assert(mathematics_min_values(values2, 4) == 6);
+}
--- a/test/mathematics_test.h
+++ b/test/mathematics_test.h
@ -17,4 +17,14 @@ void mathematics_square_root_test();

 void mathematics_factorial_test();

+void mathematics_opposite_test();
+
+void mathematics_max_test();
+
+void mathematics_max_values_test();
+
+void mathematics_min_test();
+
+void mathematics_min_values_test();
+
 #endif
--- a/test/queue_test.c
+++ b/test/queue_test.c
@ -10,6 +10,7 @@ void queue_initialization_test() {
  struct queue *queue = queue_initialization();
  assert(queue->length == 0);
  assert(queue->first == NULL);
+  queue_free(queue);
 }

 void queue_push_test() {
@ -22,6 +23,7 @@ void queue_push_test() {
  assert(((uintptr_t)queue->first->next->data) == 8);
  assert(((uintptr_t)queue->first->next->next->data) == 15);
  assert(queue->first->next->next->next == NULL);
+  queue_free(queue);
 }

 void queue_pop_test() {
@ -35,4 +37,5 @@ void queue_pop_test() {
  assert(((uintptr_t)queue->first->data) == 8);
  assert(((uintptr_t)queue->first->next->data) == 15);
  assert(queue->first->next->next == NULL);
+  queue_free(queue);
 }
--- a/test/stack_test.c
+++ b/test/stack_test.c
@ -10,6 +10,7 @@ void stack_initialization_test() {
  struct stack *stack = stack_initialization();
  assert(stack->length == 0);
  assert(stack->first == NULL);
+  stack_free(stack);
 }

 void stack_push_test() {
@ -22,6 +23,7 @@ void stack_push_test() {
  assert(((uintptr_t)stack->first->next->data) == 8);
  assert(((uintptr_t)stack->first->next->next->data) == 4);
  assert(stack->first->next->next->next == NULL);
+  stack_free(stack);
 }

 void stack_pop_test() {
@ -35,4 +37,5 @@ void stack_pop_test() {
  assert(((uintptr_t)stack->first->data) == 8);
  assert(((uintptr_t)stack->first->next->data) == 4);
  assert(stack->first->next->next == NULL);
+  stack_free(stack);
 }
--- a/test/string_test.c
+++ b/test/string_test.c
@ -5,6 +5,7 @@ void string_test() {
  string_to_uppercase_test();
  string_to_lowercase_test();
  string_replace_test();
+  string_remove_character_test();
  string_trim_start_test();
  string_trim_end_test();
  string_trim_test();
@ -24,81 +25,102 @@ void string_test() {
  string_get_last_occurence_of_character_test();
  string_starts_with_test();
  string_ends_with_test();
+  string_position_of_test();
+  string_last_position_of_test();
+  string_pad_start_test();
+  string_zero_pad_test();
 }

 void string_get_length_test() {
-  char *string = "Hello World!";
+  string_t string = "Hello World!";
  size_t string_length = string_get_length(string);
  assert(string_length == 12);
+  assert(strlen(string) == string_length);
 }

 void string_to_uppercase_test() {
-  char *string = "heLlO world";
-  string = string_to_uppercase(string);
+  string_t string = string_copy("heLlO world");
+  string_to_uppercase(string);
  assert(assert_string_equal(string, "HELLO WORLD"));
+  free(string);
 }

 void string_to_lowercase_test() {
-  char *string = "HellO WoRLd";
-  string = string_to_lowercase(string);
+  string_t string = string_copy("HellO WoRLd");
+  string_to_lowercase(string);
  assert(assert_string_equal(string, "hello world"));
+  free(string);
 }

 void string_replace_test() {
-  char *string = "hello world";
-  string = string_replace(string, 'l', 'z');
+  string_t string = string_copy("hello world");
+  string_replace(string, 'l', 'z');
  assert(assert_string_equal(string, "hezzo worzd"));
+  free(string);
+}
+
+void string_remove_character_test() {
+  string_t string = string_copy("hello world");
+  string_remove_character(string, 'l');
+  assert(assert_string_equal(string, "heo word"));
+  free(string);
 }

 void string_trim_start_test() {
-  char *string = "      hello world      ";
-  string = string_trim_start(string);
+  string_t string = string_copy("      hello world      ");
+  string_trim_start(string, ' ');
  assert(assert_string_equal(string, "hello world      "));
+  free(string);
 }

 void string_trim_end_test() {
-  char *string = "      hello world      ";
-  string = string_trim_end(string);
+  string_t string = string_copy("      hello world      ");
+  string_trim_end(string, ' ');
  assert(assert_string_equal(string, "      hello world"));
+  free(string);
 }

 void string_trim_test() {
-  char *string = "      hello world      ";
-  string = string_trim(string);
+  string_t string = string_copy("      hello world      ");
+  string_trim(string, ' ');
  assert(assert_string_equal(string, "hello world"));
+  free(string);
 }

 void string_copy_test() {
-  char *string = "hello world";
-  char *string2 = string_copy(string);
+  string_t string = "hello world";
+  string_t string2 = string_copy(string);
  assert(assert_string_equal(string, string2));
  string2[0] = 'a';
  assert(assert_string_not_equal(string, string2));
  assert(assert_string_equal(string, "hello world"));
  assert(assert_string_equal(string2, "aello world"));
+  free(string2);
 }

 void string_capitalize_test() {
-  char *string = "hello world";
-  string = string_capitalize(string);
+  string_t string = string_copy("hello world");
+  string_capitalize(string);
  assert(assert_string_equal(string, "Hello world"));
+  free(string);
 }

 void string_total_occurrences_of_character_test() {
-  char *string = "hello world";
+  string_t string = "hello world";
  assert(string_total_occurrences_of_character(string, 'l') == 3);
 }

 void string_reverse_test() {
-  char *string = "hello world";
-  string = string_reverse(string);
+  string_t string = string_copy("hello world");
+  string_reverse(string);
  assert(assert_string_equal(string, "dlrow olleh"));
+  free(string);
 }

 void string_equals_test() {
-  char *string1 = "hello world";
-  char *string2 = "dlrow olleh";
-  char *string3 = "dlrow olleh";
+  string_t string1 = "hello world";
+  string_t string2 = "dlrow olleh";
+  string_t string3 = "dlrow olleh";
  assert(!string_equals(string1, string2));
  assert(string_equals(string1, string1));
  assert(string_equals(string2, string3));
@ -117,29 +139,46 @@ void string_get_is_integer_test() {
 }

 void string_split_test() {
-  char *string = "abc def ghij kl";
+  string_t string = "abc def ghij kl";
  size_t result_length = 0;
-  char **result = string_split(string, ' ', &result_length);
+  string_t* result = string_split(string, ' ', &result_length);
  assert(result_length == 4);
  assert(assert_string_equal(result[0], "abc"));
  assert(assert_string_equal(result[1], "def"));
  assert(assert_string_equal(result[2], "ghij"));
  assert(assert_string_equal(result[3], "kl"));
+  for (size_t index = 0; index < result_length; index++) {
+    free(result[index]);
+  }
+  free(result);
 }

 void string_join_test() {
-  char *string = "abc def ghij kl";
+  string_t string = "abc def ghij kl";
  size_t result_length = 0;
-  char **result = string_split(string, ' ', &result_length);
-  char *new_string = string_join(result, ' ', result_length);
-  char *new_string2 = string_join(result, '+', result_length);
+  string_t* result = string_split(string, ' ', &result_length);
+  string_t new_string = string_join(result, ' ', result_length);
+  string_t new_string2 = string_join(result, '+', result_length);
  assert(assert_string_equal(new_string, string));
  assert(assert_string_equal(new_string2, "abc+def+ghij+kl"));
+  free(new_string);
+  free(new_string2);
+  for (size_t index = 0; index < result_length; index++) {
+    free(result[index]);
+  }
+  free(result);
 }

 void string_concatenate_test() {
-  assert(assert_string_equal(string_concatenate("abc", "def"), "abcdef"));
-  assert(assert_string_equal(string_concatenate("abc ", " defghi"), "abc  defghi"));
+  string_t result = string_copy("abc");
+  string_concatenate(&result, "def");
+  assert(assert_string_equal(result, "abcdef"));
+  free(result);
+
+  result = string_copy("abcz");
+  string_concatenate(&result, "  defghi");
+  assert(assert_string_equal(result, "abcz  defghi"));
+  free(result);
 }

 void string_get_has_unique_characters_test() {
@ -149,13 +188,14 @@ void string_get_has_unique_characters_test() {
 }

 void string_substring_test() {
-  char *string = "abcdef";
-  char *substring = string_substring(string, 1, 3);
+  string_t string = "abcdef";
+  string_t substring = string_substring(string, 1, 3);
  assert(assert_string_equal(substring, "bcd"));
+  free(substring);
 }

 void string_get_is_substring_test() {
-  char *string = "abcdef";
+  string_t string = "abcdef";
  assert(string_get_is_substring(string, "abc"));
  assert(string_get_is_substring(string, "bcd"));
  assert(string_get_is_substring(string, "de"));
@ -167,33 +207,61 @@ void string_get_is_substring_test() {
 }

 void string_get_formatted_number_test() {
-  assert(assert_string_equal(string_get_formatted_number(1000, " "), "1 000"));
-  assert(assert_string_equal(string_get_formatted_number(123, ","), "123"));
-  assert(assert_string_equal(string_get_formatted_number(1234, ","), "1,234"));
-  assert(assert_string_equal(string_get_formatted_number(12345, ","), "12,345"));
-  assert(assert_string_equal(string_get_formatted_number(123456, ","), "123,456"));
-  assert(assert_string_equal(string_get_formatted_number(1234567, ","), "1,234,567"));
-  assert(assert_string_equal(string_get_formatted_number(12345678, ","), "12,345,678"));
-  assert(assert_string_equal(string_get_formatted_number(123456789, ","), "123,456,789"));
-  assert(assert_string_equal(string_get_formatted_number(1234567890, ","), "1,234,567,890"));
-  assert(assert_string_equal(string_get_formatted_number(-123, ","), "-123"));
-  assert(assert_string_equal(string_get_formatted_number(-1234, ","), "-1,234"));
-  assert(assert_string_equal(string_get_formatted_number(-12345, ","), "-12,345"));
-  assert(assert_string_equal(string_get_formatted_number(-123456, ","), "-123,456"));
-  assert(assert_string_equal(string_get_formatted_number(-1234567, ","), "-1,234,567"));
-  assert(assert_string_equal(string_get_formatted_number(-12345678, ","), "-12,345,678"));
-  assert(assert_string_equal(string_get_formatted_number(-123456789, ","), "-123,456,789"));
-  assert(assert_string_equal(string_get_formatted_number(-1234567890, ","), "-1,234,567,890"));
+  string_t result = string_get_formatted_number(1000, " ");
+  assert(assert_string_equal(result, "1 000"));
+  free(result);
+
+  result = string_get_formatted_number(123, ",");
+  assert(assert_string_equal(result, "123"));
+  free(result);
+
+  result = string_get_formatted_number(1234, ",");
+  assert(assert_string_equal(result, "1,234"));
+  free(result);
+
+  result = string_get_formatted_number(12345, ",");
+  assert(assert_string_equal(result, "12,345"));
+  free(result);
+
+  result = string_get_formatted_number(-123, ",");
+  assert(assert_string_equal(result, "-123"));
+  free(result);
+
+  result = string_get_formatted_number(-1234, ",");
+  assert(assert_string_equal(result, "-1,234"));
+  free(result);
+
+  result = string_get_formatted_number(-1234567890, ",");
+  assert(assert_string_equal(result, "-1,234,567,890"));
+  free(result);
 }

 void string_get_last_occurence_of_character_test() {
-  char *string = "abcdef";
-  assert(assert_string_equal(string_get_last_occurence_of_character(string, 'a'), "abcdef"));
-  assert(assert_string_equal(string_get_last_occurence_of_character(string, 'b'), "bcdef"));
-  assert(assert_string_equal(string_get_last_occurence_of_character(string, 'c'), "cdef"));
-  assert(assert_string_equal(string_get_last_occurence_of_character(string, 'd'), "def"));
-  assert(assert_string_equal(string_get_last_occurence_of_character(string, 'e'), "ef"));
-  assert(assert_string_equal(string_get_last_occurence_of_character(string, 'f'), "f"));
+  string_t string = "abcdef";
+
+  string_t result = string_get_last_occurence_of_character(string, 'a');
+  assert(assert_string_equal(result, "abcdef"));
+  free(result);
+
+  result = string_get_last_occurence_of_character(string, 'b');
+  assert(assert_string_equal(result, "bcdef"));
+  free(result);
+
+  result = string_get_last_occurence_of_character(string, 'c');
+  assert(assert_string_equal(result, "cdef"));
+  free(result);
+
+  result = string_get_last_occurence_of_character(string, 'd');
+  assert(assert_string_equal(result, "def"));
+  free(result);
+
+  result = string_get_last_occurence_of_character(string, 'e');
+  assert(assert_string_equal(result, "ef"));
+  free(result);
+
+  result = string_get_last_occurence_of_character(string, 'f');
+  assert(assert_string_equal(result, "f"));
+  free(result);
 }

 void string_starts_with_test() {
@ -213,3 +281,55 @@ void string_ends_with_test() {
  assert(!string_ends_with("abcdef", "bcd"));
  assert(!string_ends_with("abcdef", "abcdefg"));
 }
+
+void string_position_of_test() {
+  assert(string_position_of("hello world", 'e') == 2);
+  assert(string_position_of("hello world", 'o') == 5);
+  assert(string_position_of("abcdef", 'a') == 1);
+  assert(string_position_of("abcdef", 'b') == 2);
+  assert(string_position_of("abcdef", 'c') == 3);
+  assert(string_position_of("abcdef", 'd') == 4);
+  assert(string_position_of("abcdef", 'e') == 5);
+  assert(string_position_of("abcdef", 'f') == 6);
+  assert(string_position_of("abcdef", 'g') == 0);
+}
+
+void string_last_position_of_test() {
+  assert(string_last_position_of("hello world", 'e') == 2);
+  assert(string_last_position_of("hello world", 'o') == 8);
+  assert(string_last_position_of("abcdef", 'a') == 1);
+  assert(string_last_position_of("abcdef", 'b') == 2);
+  assert(string_last_position_of("abcdef", 'c') == 3);
+  assert(string_last_position_of("abcdef", 'd') == 4);
+  assert(string_last_position_of("abcdef", 'e') == 5);
+  assert(string_last_position_of("abcdef", 'f') == 6);
+  assert(string_last_position_of("abcdef", 'g') == 0);
+}
+
+void string_pad_start_test() {
+  string_t result = string_pad_start("hello", "ab", 10);
+  assert(assert_string_equal(result, "ababahello"));
+  free(result);
+
+  result = string_pad_start("hello", "ab", 4);
+  assert(assert_string_equal(result, "hell"));
+  free(result);
+
+  result = string_pad_start("hello", "ab", 5);
+  assert(assert_string_equal(result, "hello"));
+  free(result);
+
+  result = string_pad_start("hello", "ab", 6);
+  assert(assert_string_equal(result, "ahello"));
+  free(result);
+}
+
+void string_zero_pad_test() {
+  string_t result = string_zero_pad(1, 2);
+  assert(assert_string_equal(result, "01"));
+  free(result);
+
+  result = string_zero_pad(10, 2);
+  assert(assert_string_equal(result, "10"));
+  free(result);
+}
--- a/test/string_test.h
+++ b/test/string_test.h
@ -18,6 +18,8 @@ void string_to_lowercase_test();

 void string_replace_test();

+void string_remove_character_test();
+
 void string_trim_start_test();

 void string_trim_end_test();
@ -56,4 +58,12 @@ void string_starts_with_test();

 void string_ends_with_test();

+void string_position_of_test();
+
+void string_last_position_of_test();
+
+void string_pad_start_test();
+
+void string_zero_pad_test();
+
 #endif
--- a/test/test.c
+++ b/test/test.c
@ -1,6 +1,6 @@
 #include "test.h"

-bool assert_string_equal(const char *actual, const char *expected) {
+bool assert_string_equal(const string_t actual, const string_t expected) {
  if (strcmp(expected, actual) != 0) {
    printf("FAIL: expected = \"%s\" ; actual = \"%s\"\n", expected, actual);
    return false;
@ -8,7 +8,7 @@ bool assert_string_equal(const char *actual, const char *expected) {
  return true;
 }

-bool assert_string_not_equal(const char *actual, const char *expected) {
+bool assert_string_not_equal(const string_t actual, const string_t expected) {
  if (strcmp(expected, actual) == 0) {
    printf("FAIL: expected = \"%s\" ; actual = \"%s\"\n", expected, actual);
    return false;
--- a/test/test.h
+++ b/test/test.h
@ -5,8 +5,10 @@
 #include <stdio.h>
 #include <string.h>

-bool assert_string_equal(const char *actual, const char *expected);
+#include "libcproject.h"

-bool assert_string_not_equal(const char *actual, const char *expected);
+bool assert_string_equal(const string_t actual, const string_t expected);
+
+bool assert_string_not_equal(const string_t actual, const string_t expected);

 #endif
--- a/version.h
+++ b/version.h
@ -1,4 +1,4 @@
 #ifndef __LIBCPROJECT_VERSION__
-#define __LIBCPROJECT_VERSION__ "1.2.0"
+#define __LIBCPROJECT_VERSION__ "4.2.1"

 #endif
Author	SHA1	Message	Date
Théo LUDWIG	2fd8d102e9	feat: add `mathematics_max`, `mathematics_min` Also add `mathematics_max_values` and `mathematics_min_values` to check in array.	2024-09-13 15:35:19 +02:00
Théo LUDWIG	85ce5228ef	feat: add `mathematics_opposite`	2024-09-13 14:44:26 +02:00
Théo LUDWIG	c49d5f5421	feat: add `string_zero_pad`	2024-09-12 12:31:58 +02:00
Théo LUDWIG	35b868d0c1	feat: add `string_pad_start`	2024-09-12 12:22:53 +02:00
Théo LUDWIG	7683aa1db7	docs(license): add email address	2024-01-30 01:25:17 +01:00
semantic-release-bot	6eee39fffb	chore(release): 4.2.1 [skip ci]	2023-12-26 20:20:38 +00:00
Théo LUDWIG	ab9860e969	fix: markdownlint in LICENSE	2023-12-26 21:19:20 +01:00
semantic-release-bot	a50773e058	chore(release): 4.2.0 [skip ci]	2023-12-26 19:47:09 +00:00
Théo LUDWIG	1e0bf99ef6	feat: add `string_last_position_of`	2023-12-26 20:40:46 +01:00
Théo LUDWIG	ec6e748d24	feat: add `string_position_of`	2023-12-26 20:30:54 +01:00
Théo LUDWIG	9bb21e070f	build(deps): update latest	2023-12-26 19:42:12 +01:00
Théo LUDWIG	bb9c7a1668	Merge branch 'master' of github.com:theoludwig/libcproject	2023-10-23 23:02:35 +02:00
Théo LUDWIG	211648d29f	chore: better Prettier config for easier reviews	2023-10-23 23:02:29 +02:00
semantic-release-bot	574aeb414e	chore(release): 4.1.1 [skip ci]	2023-10-13 09:07:49 +00:00
ChepakiLeCookie	e0115dd7d9	fix: error in array_list_remove (always removed the last index and not the index given) (#6 ) Co-authored-by: Maxime Rumpler <mrumpler68@gmail.com>	2023-10-13 11:04:38 +02:00
semantic-release-bot	269b1f7451	chore(release): 4.1.0 [skip ci]	2023-08-10 09:06:44 +00:00
Théo LUDWIG	c6df05e634	refactor: avoid usage of char*, instead use string_t	2023-08-10 00:32:49 +02:00
Théo LUDWIG	07e2f4db45	fix: convert numbers base to another only accept unsigned integers	2023-08-09 23:29:58 +02:00
Théo LUDWIG	b9ba3fbff4	docs: consistency improvements	2023-08-09 21:08:15 +02:00
Théo LUDWIG	7ef38fa993	chore: always use apt instead of apt-get	2023-08-09 20:29:19 +02:00
Théo LUDWIG	f99e4941e4	fix: correct usage of malloc and sizeof for structs	2023-08-09 20:25:03 +02:00
Théo LUDWIG	6505e3ba49	feat: add `string_remove_character`	2023-08-09 20:21:33 +02:00
Théo LUDWIG	f0716c2e12	docs: invalid `@param` for character_append	2023-08-09 20:17:54 +02:00
semantic-release-bot	78fe9ff404	chore(release): 4.0.0 [skip ci]	2023-08-08 12:24:43 +00:00
Théo LUDWIG	e5190818c4	perf: mutate destination string for `string_concatenate` BREAKING CHANGE: Function signature changed	2023-08-07 00:42:11 +02:00
Théo LUDWIG	b922fd9cd3	fix: handle EXIT_FAILURE by printing error message with perror	2023-08-07 00:11:07 +02:00
Théo LUDWIG	72645da4b2	perf: mutate strings instead of copy when possible BREAKING CHANGE: Most of string functions mutates the string instead of copying now. This allows better performance when copy is not needed. It also allows more granual control. If copy is wanted, simply use `string_copy` before calling the function. Impacted functions are: `string_to_uppercase`, `string_to_lowercase`, `string_replace`, `string_trim_start`, `string_trim_end`, `string_trim`, `string_capitalize`, `string_reverse`	2023-08-06 23:17:07 +02:00
semantic-release-bot	01e9b71402	chore(release): 3.1.0 [skip ci]	2023-08-06 14:43:01 +00:00
Théo LUDWIG	5c6f4d8192	feat: improvements to `filesystem_get_mimetype`	2023-08-06 16:39:33 +02:00
Théo LUDWIG	d604288365	docs: improve usage explanations	2023-08-06 16:12:10 +02:00
Théo LUDWIG	dff2836bfc	feat: add filesystem_remove	2023-08-06 12:14:13 +02:00
Théo LUDWIG	ad0a460923	feat: add filesystem_exists	2023-08-06 12:06:43 +02:00
semantic-release-bot	be8a63ca8a	chore(release): 3.0.0 [skip ci]	2023-08-05 13:40:47 +00:00
Théo LUDWIG	693cab7a34	chore: only use sanitizer flags in test	2023-08-05 15:33:19 +02:00
Théo LUDWIG	3220c0e26b	chore: update `@since` version	2023-08-05 15:03:53 +02:00
Théo LUDWIG	06b34b115b	feat: support giving a custom character for string_trim, string_trim_start, string_trim_end BREAKING CHANGE: Functions signatures changed. If you want to preserve the same behavior, you should pass explictly the space character to trim: Example: `string_trim(" Hello ")` => `string_trim(" Hello ", ' ')`	2023-08-05 14:19:44 +02:00
Théo LUDWIG	316dfa10e7	chore: improve Makefile to use -fsanitize=address -fsanitize=undefined gcc flags Fixes #5	2023-08-04 19:58:41 +02:00
Théo LUDWIG	145dfcf546	fix: more memory issues thanks to -fsanitize=address flag Work In Progress #5	2023-08-04 19:20:00 +02:00
Théo LUDWIG	d345c90ba3	style: fix linting	2023-08-04 00:02:35 +02:00
Théo LUDWIG	209440588d	fix: more memory issues thanks to -fsanitize=address flag Work In Progress #5	2023-08-03 23:55:14 +02:00
Théo LUDWIG	a0a1310f53	feat: add hash_map_free	2023-08-03 23:17:54 +02:00
Théo LUDWIG	8b6f06dc6e	feat: add stack_free	2023-08-03 23:01:19 +02:00
Théo LUDWIG	1e475a59b1	feat: add queue_free	2023-08-03 22:57:32 +02:00
Théo LUDWIG	6a40df3ad1	feat: add linked_list_free	2023-08-03 19:48:02 +02:00
Théo LUDWIG	d231a0f055	feat: add array_list_free	2023-08-03 19:42:50 +02:00
Théo LUDWIG	2796dec0c7	fix: memory issues thanks to -fsanitize=address flag Work In Progress #5	2023-08-03 19:35:44 +02:00
Théo LUDWIG	9717cff35a	feat: add terminal_print_array_list	2023-07-31 23:51:37 +02:00
Théo LUDWIG	368c07c57a	fix: char* issues with memory allocation Work In progress #5	2023-06-26 22:32:26 +02:00
semantic-release-bot	d774ef6ad4	chore(release): 2.0.0 [skip ci]	2023-06-25 19:42:33 +00:00
Théo LUDWIG	e7726b8cc7	ci: install documentation tools	2023-06-25 21:39:53 +02:00
Théo LUDWIG	c168a7179d	ci: check all possible Makefile paths	2023-06-25 21:37:56 +02:00
Théo LUDWIG	c5a7bbf7c1	fix: set_version typings	2023-06-25 21:35:24 +02:00
Théo LUDWIG	074d9e0acb	docs: fix doxygen warnings	2023-06-25 21:32:16 +02:00
Théo LUDWIG	0c93355e60	chore: remove .exe file extension to be more "linux way"	2023-06-25 20:17:28 +02:00
Théo LUDWIG	016bfeb47f	perf: use SipHash 1-3 algorithm for hash_map	2023-06-25 20:09:07 +02:00
Théo LUDWIG	baea00fdac	feat!: remove `dictionary` data structure Replaced by `hash_map`	2023-06-25 20:09:07 +02:00
Théo LUDWIG	256e9cb690	refactor: usage of `hash_map` instead of `dictionary`	2023-06-25 20:09:07 +02:00
Théo LUDWIG	4a11a096fa	feat: add `hash_map` data structure fixes #3	2023-06-25 20:09:07 +02:00
Théo LUDWIG	931a0b69ce	chore: replace missing string_t	2023-06-25 20:09:07 +02:00
Théo LUDWIG	682997c0a5	chore: prefix all #define for includes with LIBCPROJECT	2023-06-25 20:09:07 +02:00
Théo LUDWIG	5f60abc759	chore: remove useless @return	2023-06-25 20:09:07 +02:00
Théo LUDWIG	a0140a6716	feat: add types.h	2023-06-25 20:09:07 +02:00
Théo LUDWIG	1ded37b106	feat!: rename types `string` to `string_t` and `byte` to `byte_t`	2023-06-25 20:08:58 +02:00
Théo LUDWIG	8f3ee199e5	feat: add `string` type	2023-06-25 15:20:38 +02:00
Théo LUDWIG	ce088f8ff5	feat: add `byte` typedef	2023-06-25 15:20:38 +02:00
Théo LUDWIG	eb798a619a	fix: update `filesystem_read` and `filesystem_write` signatures BREAKING CHANGE: take a `uint8_t` for file_content instead of `char` It makes more sense to treat files as array of "bytes", not only characters/text files.	2023-06-25 15:20:07 +02:00
Théo LUDWIG	b9f573bfb2	feat: support more mimetypes for filesystem_get_mimetype	2023-06-24 21:15:55 +02:00
Théo LUDWIG	b665e3629d	fix: handle filesystem read and write errors	2023-06-24 21:13:00 +02:00
Théo LUDWIG	d42ec38e36	ci: add gcc --version	2023-06-24 21:09:19 +02:00
Théo LUDWIG	d1b93d1da0	docs: add `@since` to know when a structure/function was added	2023-06-24 21:06:45 +02:00
Théo LUDWIG	071b645cb4	build(deps): update doxygen-awesome-css to v2.2.1	2023-06-24 20:44:48 +02:00
Théo LUDWIG	e5d07d73cd	ci: set dependencies version explicitly	2023-06-24 20:39:14 +02:00
Théo LUDWIG	d850f04069	perf: compile with -O3 gcc flag	2023-06-24 20:30:34 +02:00
Théo LUDWIG	20d31ba2e3	fix: update author - Théo LUDWIG	2023-06-24 20:29:30 +02:00