chore(release): 4.3.0 [skip ci]

Also add `mathematics_max_values` and
`mathematics_min_values` to check in array.

.clang-format

@@ -1,2 +1,2 @@
-BasedOnStyle: 'Google'
+BasedOnStyle: "Google"
 ColumnLimit: 0

.github/ISSUE_TEMPLATE/BUG.md

@@ -1,8 +1,8 @@
 ---
-name: '🐛 Bug Report'
+name: "🐛 Bug Report"
-about: 'Report an unexpected problem or unintended behavior.'
+about: "Report an unexpected problem or unintended behavior."
-title: '[Bug]'
+title: "[Bug]"
-labels: 'bug'
+labels: "bug"
 ---
 
 <!--

.github/ISSUE_TEMPLATE/DOCUMENTATION.md

@@ -1,8 +1,8 @@
 ---
-name: '📜 Documentation'
+name: "📜 Documentation"
-about: 'Correct spelling errors, improvements or additions to documentation files (README, CONTRIBUTING...).'
+about: "Correct spelling errors, improvements or additions to documentation files (README, CONTRIBUTING...)."
-title: '[Documentation]'
+title: "[Documentation]"
-labels: 'documentation'
+labels: "documentation"
 ---
 
 <!-- Please make sure your issue has not already been fixed. -->

.github/ISSUE_TEMPLATE/FEATURE_REQUEST.md

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

.github/ISSUE_TEMPLATE/IMPROVEMENT.md

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

.github/ISSUE_TEMPLATE/QUESTION.md

@@ -1,8 +1,8 @@
 ---
-name: '🙋 Question'
+name: "🙋 Question"
-about: 'Further information is requested.'
+about: "Further information is requested."
-title: '[Question]'
+title: "[Question]"
-labels: 'question'
+labels: "question"
 ---
 
 ### Question

.github/workflows/ci.yml

@@ -1,40 +1,40 @@
-name: 'CI'
+name: "CI"
 
 on:
   push:
     branches: [develop]
   pull_request:
-    branches: [master, develop]
+    branches: [main, develop]
 
 jobs:
   ci:
-    runs-on: 'ubuntu-latest'
+    runs-on: "ubuntu-latest"
     steps:
-      - uses: 'actions/checkout@v3.5.3'
+      - uses: "actions/checkout@v4.1.7"
 
-      - run: 'sudo apt update'
+      - run: "sudo apt update"
 
-      - name: 'Install Build Tools'
+      - name: "Install Build Tools"
-        run: 'sudo apt install --yes build-essential gcc make clang-format'
+        run: "sudo apt install --yes build-essential gcc make clang-format"
 
-      - name: 'Install Documentation Tools'
+      - name: "Install Documentation Tools"
-        run: 'sudo apt install --yes doxygen doxygen-gui doxygen-doc graphviz'
+        run: "sudo apt install --yes doxygen doxygen-gui doxygen-doc graphviz"
 
-      - run: 'gcc --version'
+      - run: "gcc --version"
 
-      - run: 'make'
+      - run: "make"
-      - run: 'make run'
+      - run: "make run"
-      - run: 'make test'
+      - run: "make test"
-      - run: 'make lint'
+      - run: "make lint"
-      - run: 'make documentation'
+      - run: "make documentation"
-      - run: 'make set_version'
+      - run: "make set_version"
-      - run: 'make clean'
+      - run: "make clean"
 
   lint-commit:
-      runs-on: 'ubuntu-latest'
+    runs-on: "ubuntu-latest"
     steps:
-        - uses: 'actions/checkout@v3.5.3'
+      - uses: "actions/checkout@v4.1.7"
         with:
           fetch-depth: 0
 
-        - uses: 'wagoid/commitlint-github-action@v5.4.1'
+      - uses: "wagoid/commitlint-github-action@v6.1.2"

.github/workflows/release.yml

@@ -1,57 +1,57 @@
-name: 'Release'
+name: "Release"
 
 on:
   push:
-    branches: [master]
+    branches: [main]
 
 jobs:
   release:
-    runs-on: 'ubuntu-latest'
+    runs-on: "ubuntu-latest"
     steps:
-      - uses: 'actions/checkout@v3.5.3'
+      - uses: "actions/checkout@v4.1.7"
         with:
           fetch-depth: 0
           persist-credentials: false
-          submodules: recursive
+          submodules: "recursive"
 
-      - name: 'Import GPG key'
+      - name: "Import GPG key"
-        uses: 'crazy-max/ghaction-import-gpg@v5.3.0'
+        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
 
-      - run: 'sudo apt update'
+      - run: "sudo apt update"
 
-      - name: 'Install Build Tools'
+      - name: "Install Build Tools"
-        run: 'sudo apt install --yes build-essential gcc make clang-format'
+        run: "sudo apt install --yes build-essential gcc make clang-format"
 
-      - name: 'Install Documentation Tools'
+      - name: "Install Documentation Tools"
-        run: 'sudo apt install --yes doxygen doxygen-gui doxygen-doc graphviz'
+        run: "sudo apt install --yes doxygen doxygen-gui doxygen-doc graphviz"
 
-      - run: 'make set_version'
+      - run: "make set_version"
 
-      - name: 'Use Node.js'
+      - name: "Use Node.js"
-        uses: 'actions/setup-node@v3.7.0'
+        uses: "actions/setup-node@v4.0.3"
         with:
-          node-version: '18.17.0'
+          node-version: "20.17.0"
 
-      - name: 'Install Release Tools'
+      - name: "Install Release Tools"
-        run: 'npm install --save-dev semantic-release@21.0.7 @commitlint/cli@17.6.7 @commitlint/config-conventional@17.6.7 @semantic-release/git@10.0.1 @semantic-release/exec@6.0.3 @saithodev/semantic-release-backmerge@3.2.0 vercel@31.2.2'
+        run: "npm install --save-dev semantic-release@23.1.1 @commitlint/cli@19.5.0 @commitlint/config-conventional@19.5.0 @semantic-release/git@10.0.1 @semantic-release/exec@6.0.3 @saithodev/semantic-release-backmerge@4.0.1 vercel@37.4.2"
 
-      - run: 'rm --force package.json package-lock.json'
+      - run: "rm --force package.json package-lock.json"
 
-      - name: 'Release'
+      - name: "Release"
-        run: 'npx semantic-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'
+      - name: "Generate Documentation"
-        run: 'make 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 }}

.releaserc.json

@@ -1,5 +1,5 @@
 {
-  "branches": ["master"],
+  "branches": ["main"],
   "plugins": [
     [
       "@semantic-release/commit-analyzer",
@@ -30,7 +30,7 @@
     [
       "@saithodev/semantic-release-backmerge",
       {
-        "branches": [{ "from": "master", "to": "develop" }],
+        "branches": [{ "from": "main", "to": "develop" }],
         "backmergeStrategy": "merge"
       }
     ]

CONTRIBUTING.md

@@ -30,3 +30,18 @@ If you're adding new features to **libcproject**, please include tests.
 ## Commits
 
 The commit message guidelines adheres to [Conventional Commits](https://www.conventionalcommits.org/) and [Semantic Versioning](https://semver.org/) for releases.
+
+## Git Submodules
+
+To get the submodule:
+
+```sh
+git submodule update --init --recursive
+```
+
+To update the version:
+
+```sh
+cd doxygen-awesome-css
+git checkout v2.3.3
+```

LICENSE

@@ -1,6 +1,6 @@
-MIT License
+# MIT License
 
-Copyright (c) Théo LUDWIG
+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

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/theoludwig/libcproject/actions/workflows/ci.yml"><img src="https://github.com/theoludwig/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>

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++) {
+  for (size_t i = index; i < list->size - 1; i++) {
-    list->data[i - 1] = list->data[i];
+    list->data[i] = list->data[i + 1];
   }
   list->size--;
 }

lib/date.c

@@ -0,0 +1,287 @@
+#include "date.h"
+
+struct date *date_copy(struct date *date_to_copy) {
+  struct date *date = malloc(sizeof(struct date));
+  if (date == NULL) {
+    perror("Error (date_copy)");
+    exit(EXIT_FAILURE);
+  }
+  date->year = date_to_copy->year;
+  date->month = date_to_copy->month;
+  date->day = date_to_copy->day;
+  date->hours = date_to_copy->hours;
+  date->minutes = date_to_copy->minutes;
+  date->seconds = date_to_copy->seconds;
+  date->milliseconds = date_to_copy->milliseconds;
+  date->timezone_utc_offset = date_to_copy->timezone_utc_offset;
+  return date;
+}
+
+bool date_get_is_valid_year(uint16_t year) {
+  return year <= 9999;
+}
+
+bool date_get_is_valid_month(uint8_t month) {
+  return month >= 1 && month <= 12;
+}
+
+bool date_get_is_valid_day(uint8_t day) {
+  return day >= 1 && day <= 31;
+}
+
+bool date_get_is_valid_hours(uint8_t hours) {
+  return hours <= 23;
+}
+
+bool date_get_is_valid_minutes(uint8_t minutes) {
+  return minutes <= 59;
+}
+
+bool date_get_is_valid_seconds(uint8_t seconds) {
+  return seconds <= 59;
+}
+
+bool date_get_is_valid_milliseconds(uint16_t milliseconds) {
+  return milliseconds <= 999;
+}
+
+bool date_get_is_valid_timezone_utc_offset(int8_t timezone_utc_offset) {
+  return timezone_utc_offset >= -12 && timezone_utc_offset <= 14;
+}
+
+bool date_get_is_valid(struct date *date) {
+  size_t date_days_of_month = date_get_days_of_month(date->month, date->year);
+  return (date_get_is_valid_month(date->month) &&
+          date_get_is_valid_day(date->day) &&
+          date->day <= date_days_of_month &&
+          date_get_is_valid_hours(date->hours) &&
+          date_get_is_valid_minutes(date->minutes) &&
+          date_get_is_valid_seconds(date->seconds) &&
+          date_get_is_valid_milliseconds(date->milliseconds) &&
+          date_get_is_valid_timezone_utc_offset(date->timezone_utc_offset));
+}
+
+string_t date_to_iso_string(struct date *date_original) {
+  struct date *date = date_copy(date_original);
+  date_to_utc(date);
+
+  size_t iso_string_length = 24;
+  string_t result = malloc(sizeof(char) * (iso_string_length + 1));
+
+  string_t year_string = string_zero_pad(date->year, 4);
+  string_t month_string = string_zero_pad(date->month, 2);
+  string_t day_string = string_zero_pad(date->day, 2);
+  string_t hours_string = string_zero_pad(date->hours, 2);
+  string_t minutes_string = string_zero_pad(date->minutes, 2);
+  string_t seconds_string = string_zero_pad(date->seconds, 2);
+  string_t milliseconds_string = string_zero_pad(date->milliseconds, 3);
+  sprintf(result, "%s-%s-%sT%s:%s:%s.%sZ", year_string, month_string, day_string, hours_string, minutes_string, seconds_string, milliseconds_string);
+  free(year_string);
+  free(month_string);
+  free(day_string);
+  free(hours_string);
+  free(minutes_string);
+  free(seconds_string);
+  free(milliseconds_string);
+
+  free(date);
+  return result;
+}
+
+string_t date_to_iso_string_without_time(struct date *date) {
+  size_t iso_string_length = 10;
+  string_t result = malloc(sizeof(char) * (iso_string_length + 1));
+  if (result == NULL) {
+    perror("Error (date_to_iso_string_without_time)");
+    exit(EXIT_FAILURE);
+  }
+
+  string_t year_string = string_zero_pad(date->year, 4);
+  string_t month_string = string_zero_pad(date->month, 2);
+  string_t day_string = string_zero_pad(date->day, 2);
+  sprintf(result, "%s-%s-%s", year_string, month_string, day_string);
+  free(year_string);
+  free(month_string);
+  free(day_string);
+
+  return result;
+}
+
+struct date *date_from_iso_string(string_t iso_string) {
+  struct date *date = malloc(sizeof(struct date));
+  if (date == NULL) {
+    perror("Error (date_from_iso_string)");
+    exit(EXIT_FAILURE);
+  }
+
+  string_t year_string = string_substring(iso_string, 0, 3);
+  date->year = (uint16_t)convert_string_to_number(year_string);
+  free(year_string);
+
+  string_t month_string = string_substring(iso_string, 5, 6);
+  date->month = (uint8_t)convert_string_to_number(month_string);
+  free(month_string);
+
+  string_t day_string = string_substring(iso_string, 8, 9);
+  date->day = (uint8_t)convert_string_to_number(day_string);
+  free(day_string);
+
+  string_t hours_string = string_substring(iso_string, 11, 12);
+  date->hours = (uint8_t)convert_string_to_number(hours_string);
+  free(hours_string);
+
+  string_t minutes_string = string_substring(iso_string, 14, 15);
+  date->minutes = (uint8_t)convert_string_to_number(minutes_string);
+  free(minutes_string);
+
+  string_t seconds_string = string_substring(iso_string, 17, 18);
+  date->seconds = (uint8_t)convert_string_to_number(seconds_string);
+  free(seconds_string);
+
+  string_t milliseconds_string = string_substring(iso_string, 20, 22);
+  date->milliseconds = (uint16_t)convert_string_to_number(milliseconds_string);
+  free(milliseconds_string);
+
+  date->timezone_utc_offset = 0;
+
+  return date;
+}
+
+uint8_t date_get_days_of_month(uint8_t month, uint16_t year) {
+  switch (month) {
+    case 1:
+      return 31;
+    case 2:
+      return date_get_is_leap_year(year) ? 29 : 28;
+    case 3:
+      return 31;
+    case 4:
+      return 30;
+    case 5:
+      return 31;
+    case 6:
+      return 30;
+    case 7:
+      return 31;
+    case 8:
+      return 31;
+    case 9:
+      return 30;
+    case 10:
+      return 31;
+    case 11:
+      return 30;
+    case 12:
+      return 31;
+    default:
+      return 0;
+  }
+}
+
+bool date_get_is_leap_year(uint16_t year) {
+  return (year % 4 == 0 && year % 100 != 0) || year % 400 == 0;
+}
+
+uint64_t date_convert_milliseconds_to_seconds(uint16_t milliseconds) {
+  return milliseconds / MILLISECONDS_PER_SECOND;
+}
+
+uint64_t date_convert_seconds_to_milliseconds(uint64_t seconds) {
+  return seconds * MILLISECONDS_PER_SECOND;
+}
+
+uint64_t date_convert_days_to_seconds(uint64_t days) {
+  return days * SECONDS_PER_DAY;
+}
+
+uint64_t date_convert_hms_to_seconds(uint8_t hours, uint8_t minutes, uint8_t seconds) {
+  return (hours * SECONDS_PER_HOUR) + (minutes * SECONDS_PER_MINUTE) + seconds;
+}
+
+uint64_t date_to_total_seconds(struct date *date) {
+  uint64_t total_seconds = 0;
+
+  for (uint16_t year = 0; year < date->year; year++) {
+    total_seconds += 365 * SECONDS_PER_DAY;
+    if (date_get_is_leap_year(year)) {
+      total_seconds += SECONDS_PER_DAY;
+    }
+  }
+
+  for (uint8_t month = 1; month < date->month; month++) {
+    total_seconds += date_convert_days_to_seconds(date_get_days_of_month(month, date->year));
+  }
+
+  total_seconds += date_convert_days_to_seconds(date->day - 1);
+  total_seconds += date_convert_hms_to_seconds(date->hours, date->minutes, date->seconds);
+
+  return total_seconds;
+}
+
+uint64_t date_duration_seconds_between_2_dates(struct date *date1, struct date *date2) {
+  struct date *utc_date1 = date_copy(date1);
+  struct date *utc_date2 = date_copy(date2);
+  date_to_utc(utc_date1);
+  date_to_utc(utc_date2);
+
+  uint64_t total_seconds_date1 = date_to_total_seconds(utc_date1);
+  uint64_t total_seconds_date2 = date_to_total_seconds(utc_date2);
+
+  free(utc_date1);
+  free(utc_date2);
+
+  return total_seconds_date1 > total_seconds_date2 ? total_seconds_date1 - total_seconds_date2 : total_seconds_date2 - total_seconds_date1;
+}
+
+void date_add_hours(struct date *date, int64_t hours) {
+  if (hours == 0) {
+    return;
+  }
+  int64_t total_hours = date->hours + hours;
+  int64_t additional_days = total_hours / 24;
+  int64_t new_hours = total_hours % 24;
+
+  if (new_hours < 0) {
+    new_hours += 24;
+    additional_days -= 1;
+  }
+
+  date->hours = (uint8_t)new_hours;
+
+  if (additional_days != 0) {
+    date->day += additional_days;
+
+    while (date->day > date_get_days_of_month(date->month, date->year)) {
+      date->day -= date_get_days_of_month(date->month, date->year);
+      date->month++;
+
+      if (date->month > 12) {
+        date->month = 1;
+        date->year++;
+      }
+    }
+
+    while (date->day < 1) {
+      date->month--;
+      if (date->month < 1) {
+        date->month = 12;
+        date->year--;
+      }
+
+      date->day += date_get_days_of_month(date->month, date->year);
+    }
+  }
+}
+
+void date_add_days(struct date *date, int64_t days) {
+  date_add_hours(date, days * 24);
+}
+
+void date_to_utc(struct date *date) {
+  if (date->timezone_utc_offset == 0) {
+    return;
+  }
+  int8_t timezone_utc_offset = date->timezone_utc_offset;
+  date->timezone_utc_offset = 0;
+  date_add_hours(date, mathematics_opposite(timezone_utc_offset));
+}

lib/date.h

@@ -0,0 +1,324 @@
+#ifndef __LIBCPROJECT_DATE__
+#define __LIBCPROJECT_DATE__
+
+#include <errno.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+#include "convert.h"
+#include "mathematics.h"
+#include "string.h"
+#include "types.h"
+
+#define SECONDS_PER_MINUTE 60
+#define SECONDS_PER_HOUR (60 * SECONDS_PER_MINUTE)
+#define SECONDS_PER_DAY (24 * SECONDS_PER_HOUR)
+#define MILLISECONDS_PER_SECOND 1000
+
+/**
+ * @brief Date object representing a single moment in time.
+ * @since v4.3.0
+ */
+struct date {
+  /**
+   * Year.
+   * Between [0, 9999] (inclusive).
+   * As per ISO 8601, a four-digit year [YYYY] and represents years from 0000 to 9999, year 0000 being equal to 1 BC and all others AD.
+   */
+  uint16_t year;
+
+  /**
+   * Month.
+   * Between [1, 12] (inclusive).
+   */
+  uint8_t month;
+
+  /**
+   * Day.
+   * Between [1, 31] (inclusive).
+   */
+  uint8_t day;
+
+  /**
+   * Hours.
+   * Between [0, 23] (inclusive).
+   */
+  uint8_t hours;
+
+  /**
+   * Minutes.
+   * Between [0, 59] (inclusive).
+   */
+  uint8_t minutes;
+
+  /**
+   * Seconds.
+   * Between [0, 59] (inclusive).
+   */
+  uint8_t seconds;
+
+  /**
+   * Milliseconds.
+   * Between [0, 999] (inclusive).
+   */
+  uint16_t milliseconds;
+
+  /**
+   * Timezone UTC offset.
+   * Between [-12, 14]
+   */
+  int8_t timezone_utc_offset;
+};
+
+/**
+ * @brief Return the copy of a date.
+ *
+ * @param date
+ * @return struct date*
+ * @since v4.3.0
+ */
+struct date *date_copy(struct date *date_to_copy);
+
+/**
+ * @brief Check if a year is valid, between [0, 9999] (inclusive).
+ *
+ * @param year
+ * @return bool
+ * @since v4.3.0
+ */
+bool date_get_is_valid_year(uint16_t year);
+
+/**
+ * @brief Check if a month is valid, between [1, 12] (inclusive).
+ *
+ * @param month
+ * @return bool
+ * @since v4.3.0
+ */
+bool date_get_is_valid_month(uint8_t month);
+
+/**
+ * @brief Check if a day is valid, between [1, 31] (inclusive).
+ *
+ * @param day
+ * @return bool
+ * @since v4.3.0
+ */
+bool date_get_is_valid_day(uint8_t day);
+
+/**
+ * @brief Check if hours are valid, between [0, 23] (inclusive).
+ *
+ * @param hours
+ * @return bool
+ * @since v4.3.0
+ */
+bool date_get_is_valid_hours(uint8_t hours);
+
+/**
+ * @brief Check if minutes are valid, between [0, 59] (inclusive).
+ *
+ * @param minutes
+ * @return bool
+ * @since v4.3.0
+ */
+bool date_get_is_valid_minutes(uint8_t minutes);
+
+/**
+ * @brief Check if seconds are valid, between [0, 59] (inclusive).
+ *
+ * @param seconds
+ * @return bool
+ * @since v4.3.0
+ */
+bool date_get_is_valid_seconds(uint8_t seconds);
+
+/**
+ * @brief Check if milliseconds are valid, between [0, 999] (inclusive).
+ *
+ * @param milliseconds
+ * @return bool
+ * @since v4.3.0
+ */
+bool date_get_is_valid_milliseconds(uint16_t milliseconds);
+
+/**
+ * @brief Check if the timezone UTC offset is valid, between [-12, 14] (inclusive).
+ *
+ * @param timezone_utc_offset
+ * @return bool
+ * @since v4.3.0
+ */
+bool date_get_is_valid_timezone_utc_offset(int8_t timezone_utc_offset);
+
+/**
+ * @brief Check if the date is valid (all fields are possible).
+ *
+ * @param date
+ * @return bool
+ * @since v4.3.0
+ */
+bool date_get_is_valid(struct date *date);
+
+/**
+ * @brief String representing the date in the date time string format, a simplified format based on ISO 8601, which is always 24 characters long (`YYYY-MM-DDTHH:mm:ss.sssZ`). The timezone is always UTC, as denoted by the suffix `Z`.
+ *
+ * @param date
+ * @return string_t
+ *
+ * @code
+ * date_to_iso_string() // "2024-09-11T09:39:18.203Z"
+ * @endcode
+ *
+ * @since v4.3.0
+ */
+string_t date_to_iso_string(struct date *date);
+
+/**
+ * @brief String representing the date in the ISO 8601 format, without time information (`YYYY-MM-DD`).
+ *
+ * @param date
+ * @return string_t
+ *
+ * @code
+ * date_to_iso_string_without_time() // "2024-09-11"
+ * @endcode
+ *
+ * @since v4.3.0
+ */
+string_t date_to_iso_string_without_time(struct date *date);
+
+/**
+ * @brief Create a date from an ISO 8601 string, with the format `YYYY-MM-DDTHH:mm:ss.sssZ`.
+ *
+ * The timezone is always UTC, as denoted by the suffix `Z`.
+ *
+ * @param iso_string
+ * @return struct date*
+ * @since v4.3.0
+ */
+struct date *date_from_iso_string(string_t iso_string);
+
+/**
+ * @brief Get number of days in one month [1, 12].
+ *
+ * @param month
+ * @return uint8_t
+ * @since v4.3.0
+ */
+uint8_t date_get_days_of_month(uint8_t month, uint16_t year);
+
+/**
+ * @brief Determine if a year is a leap year.
+ *
+ * @param year
+ * @return bool
+ *
+ * @code
+ * date_is_leap_year(2020) // true
+ *
+ * date_is_leap_year(2021) // false
+ *
+ * date_is_leap_year(2022) // false
+ *
+ * date_is_leap_year(2023) // false
+ *
+ * date_is_leap_year(2024) // true
+ * @endcode
+ *
+ * @since v4.3.0
+ */
+bool date_get_is_leap_year(uint16_t year);
+
+/**
+ * @brief Convert milliseconds to seconds.
+ *
+ * @param milliseconds
+ * @return uint64_t
+ * @since v4.3.0
+ */
+uint64_t date_convert_milliseconds_to_seconds(uint16_t milliseconds);
+
+/**
+ * @brief Convert seconds to milliseconds.
+ *
+ * @param seconds
+ * @return uint64_t
+ * @since v4.3.0
+ */
+uint64_t date_convert_seconds_to_milliseconds(uint64_t seconds);
+
+/**
+ * @brief Convert days to seconds.
+ *
+ * @param days
+ * @return uint64_t
+ * @since v4.3.0
+ */
+uint64_t date_convert_days_to_seconds(uint64_t days);
+
+/**
+ * @brief Convert hours, minutes, and seconds to seconds.
+ *
+ * @param hours
+ * @param minutes
+ * @param seconds
+ * @return uint64_t
+ * @since v4.3.0
+ */
+uint64_t date_convert_hms_to_seconds(uint8_t hours, uint8_t minutes, uint8_t seconds);
+
+/**
+ * @brief Convert a date to total seconds.
+ *
+ * @param date
+ * @return uint64_t
+ * @since v4.3.0
+ */
+uint64_t date_to_total_seconds(struct date *date);
+
+/**
+ * @brief Calculate the duration in seconds between 2 dates.
+ *
+ * @param date1
+ * @param date2
+ * @return uint64_t
+ * @since v4.3.0
+ */
+uint64_t date_duration_seconds_between_2_dates(struct date *date1, struct date *date2);
+
+/**
+ * @brief Add hours to the date, managing the day, month, year changes if necessary.
+ *
+ * NOTE: Mutates the date.
+ *
+ * @param date
+ * @param hours
+ * @since v4.3.0
+ */
+void date_add_hours(struct date *date, int64_t hours);
+
+/**
+ * @brief Adds days to the date, managing month and year changes as needed.
+ *
+ * NOTE: Mutates the date.
+ *
+ * @param date The date to which days are being added.
+ * @param days The number of days to add.
+ * @since v4.3.0
+ */
+void date_add_days(struct date *date, int64_t days);
+
+/**
+ * @brief Transform the date with a Timezone UTC Offset to UTC (timezone_utc_offset = 0).
+ *
+ * NOTE: Mutates the date.
+ *
+ * @param date
+ * @since v4.3.0
+ */
+void date_to_utc(struct date *date);
+
+#endif

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;
+}

lib/mathematics.h

@@ -5,6 +5,7 @@
 
 #include <errno.h>
 #include <stdbool.h>
+#include <stdlib.h>
 
 #include "types.h"
 
@@ -66,4 +67,59 @@ float mathematics_square_root(float number);
  */
 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 v4.3.0
+ */
+int64_t mathematics_opposite(int64_t number);
+
+/**
+ * @brief Returns the largest number between 2 numbers.
+ *
+ * @param number1
+ * @param number2
+ * @return int64_t
+ * @since v4.3.0
+ */
+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 v4.3.0
+ */
+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 v4.3.0
+ */
+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 v4.3.0
+ */
+int64_t mathematics_min_values(int64_t *values, size_t values_length);
+
 #endif

lib/string.c

@@ -384,3 +384,59 @@ bool string_ends_with(const string_t string, const string_t 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;
+}

lib/string.h

@@ -224,8 +224,10 @@ bool string_get_is_substring(const string_t string, const string_t substring);
  * @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
@@ -264,4 +266,63 @@ bool string_starts_with(const string_t string, const string_t 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 v4.3.0
+ */
+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 v4.3.0
+ */
+string_t string_zero_pad(uint64_t number, size_t places);
+
 #endif

libcproject.h

@@ -4,6 +4,7 @@
 #include "lib/array_list.h"
 #include "lib/character.h"
 #include "lib/convert.h"
+#include "lib/date.h"
 #include "lib/filesystem.h"
 #include "lib/hash_map.h"
 #include "lib/linked_list.h"

test/array_list_test.c

@@ -34,4 +34,15 @@ void array_list_test() {
   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);
 }

test/date_test.c

@@ -0,0 +1,164 @@
+#include "date_test.h"
+
+void date_test() {
+  date_copy_test();
+  date_to_iso_string_test();
+  date_to_iso_string_without_time_test();
+  date_from_iso_string_test();
+  date_get_is_leap_year_test();
+  date_duration_seconds_between_2_dates_test();
+  date_to_utc_test();
+}
+
+void date_copy_test() {
+  struct date *date = malloc(sizeof(struct date));
+  date->year = 2024;
+  date->month = 9;
+  date->day = 10;
+  date->hours = 20;
+  date->minutes = 34;
+  date->seconds = 25;
+  date->milliseconds = 76;
+  date->timezone_utc_offset = 0;
+
+  struct date *date2 = date_copy(date);
+  assert(date != date2);
+  assert(date->year == date2->year);
+  assert(date->month == date2->month);
+  assert(date->day == date2->day);
+  assert(date->hours == date2->hours);
+  assert(date->minutes == date2->minutes);
+  assert(date->seconds == date2->seconds);
+  assert(date->milliseconds == date2->milliseconds);
+  assert(date->timezone_utc_offset == date2->timezone_utc_offset);
+
+  date->year = 2025;
+  assert(date->year == 2025);
+  assert(date2->year == 2024);
+
+  free(date);
+  free(date2);
+}
+
+void date_to_iso_string_test() {
+  struct date *date = malloc(sizeof(struct date));
+  date->year = 2024;
+  date->month = 9;
+  date->day = 10;
+  date->hours = 20;
+  date->minutes = 34;
+  date->seconds = 25;
+  date->milliseconds = 76;
+  date->timezone_utc_offset = 0;
+
+  string_t iso_string = date_to_iso_string(date);
+  assert(assert_string_equal(iso_string, "2024-09-10T20:34:25.076Z"));
+  free(iso_string);
+
+  free(date);
+}
+
+void date_to_iso_string_without_time_test() {
+  struct date *date = malloc(sizeof(struct date));
+  date->year = 2024;
+  date->month = 9;
+  date->day = 10;
+  date->hours = 20;
+  date->minutes = 34;
+  date->seconds = 25;
+  date->milliseconds = 76;
+  date->timezone_utc_offset = 0;
+
+  string_t iso_string = date_to_iso_string_without_time(date);
+  assert(assert_string_equal(iso_string, "2024-09-10"));
+  free(iso_string);
+
+  free(date);
+}
+
+void date_from_iso_string_test() {
+  string_t iso_string = "2024-09-10T20:34:25.076Z";
+  struct date *date = date_from_iso_string(iso_string);
+  assert(date->year == 2024);
+  assert(date->month == 9);
+  assert(date->day == 10);
+  assert(date->hours == 20);
+  assert(date->minutes == 34);
+  assert(date->seconds == 25);
+  assert(date->milliseconds == 76);
+  assert(date->timezone_utc_offset == 0);
+
+  free(date);
+}
+
+void date_get_is_leap_year_test() {
+  assert(date_get_is_leap_year(2020));
+  assert(!date_get_is_leap_year(2021));
+  assert(!date_get_is_leap_year(2022));
+  assert(!date_get_is_leap_year(2023));
+  assert(date_get_is_leap_year(2024));
+}
+
+void date_duration_seconds_between_2_dates_test() {
+  struct date *date1 = date_from_iso_string("2024-09-10T20:34:25.076Z");
+  struct date *date2 = date_from_iso_string("2024-09-10T20:34:25.076Z");
+  assert(date_duration_seconds_between_2_dates(date1, date2) == 0);
+  free(date1);
+  free(date2);
+
+  date1 = date_from_iso_string("2024-09-10T20:34:25.076Z");
+  date2 = date_from_iso_string("2024-09-10T23:34:26.076Z");
+  assert(date_duration_seconds_between_2_dates(date1, date2) == 10801);
+  free(date1);
+  free(date2);
+
+  date1 = date_from_iso_string("2024-09-10T20:34:25.076Z");
+  date2 = date_from_iso_string("2024-09-10T20:48:25.076Z");
+  assert(date_duration_seconds_between_2_dates(date1, date2) == 840);
+  free(date1);
+  free(date2);
+
+  date1 = date_from_iso_string("2024-09-10T20:34:25.076Z");
+  date2 = date_from_iso_string("2024-09-10T20:34:38.076Z");
+  assert(date_duration_seconds_between_2_dates(date1, date2) == 13);
+  free(date1);
+  free(date2);
+}
+
+void date_to_utc_test() {
+  struct date *date = date_from_iso_string("2024-09-10T20:34:25.076Z");
+  date->timezone_utc_offset = 3;
+  date_to_utc(date);
+  assert(date->timezone_utc_offset == 0);
+  string_t iso_string = date_to_iso_string(date);
+  assert(assert_string_equal(iso_string, "2024-09-10T17:34:25.076Z"));
+  free(iso_string);
+  free(date);
+
+  date = date_from_iso_string("2024-09-10T20:34:25.076Z");
+  date->timezone_utc_offset = -3;
+  date_to_utc(date);
+  assert(date->timezone_utc_offset == 0);
+  iso_string = date_to_iso_string(date);
+  assert(assert_string_equal(iso_string, "2024-09-10T23:34:25.076Z"));
+  free(iso_string);
+  free(date);
+
+  date = date_from_iso_string("2024-01-01T00:00:00.000Z");
+  date->timezone_utc_offset = 3;
+  date_to_utc(date);
+  assert(date->timezone_utc_offset == 0);
+  iso_string = date_to_iso_string(date);
+  assert(assert_string_equal(iso_string, "2023-12-31T21:00:00.000Z"));
+  free(iso_string);
+  free(date);
+
+  date = date_from_iso_string("2023-12-31T21:00:00.000Z");
+  date->timezone_utc_offset = -4;
+  date_to_utc(date);
+  assert(date->timezone_utc_offset == 0);
+  iso_string = date_to_iso_string(date);
+  assert(assert_string_equal(iso_string, "2024-01-01T01:00:00.000Z"));
+  free(iso_string);
+  free(date);
+}

test/date_test.h

@@ -0,0 +1,25 @@
+#ifndef __DATE_TEST__
+#define __DATE_TEST__
+
+#include <assert.h>
+
+#include "libcproject.h"
+#include "test.h"
+
+void date_test();
+
+void date_copy_test();
+
+void date_to_iso_string_test();
+
+void date_to_iso_string_without_time_test();
+
+void date_from_iso_string_test();
+
+void date_get_is_leap_year_test();
+
+void date_duration_seconds_between_2_dates_test();
+
+void date_to_utc_test();
+
+#endif

test/main.c

@@ -4,6 +4,7 @@
 #include "array_list_test.h"
 #include "character_test.h"
 #include "convert_test.h"
+#include "date_test.h"
 #include "hash_map_test.h"
 #include "linked_list_test.h"
 #include "mathematics_test.h"
@@ -15,6 +16,7 @@ int main() {
   array_list_test();
   character_test();
   convert_test();
+  date_test();
   hash_map_test();
   linked_list_test();
   mathematics_test();

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);
+}

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

test/string_test.c

@@ -25,6 +25,10 @@ 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() {
@@ -277,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);
+}

test/string_test.h

@@ -58,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

version.h

@@ -1,4 +1,4 @@
 #ifndef __LIBCPROJECT_VERSION__
-#define __LIBCPROJECT_VERSION__ "4.1.0"
+#define __LIBCPROJECT_VERSION__ "4.3.0"
 
 #endif