#include <stdarg.h>
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
#include <stdlib.h>

Data Structures
struct	AirUuid
	UUID 128 bits, POD ABI C (RFC 9562, octets big-endian / ordre réseau). More...

struct	AirId128
	Identifiant 128 bits générique, POD ABI C (concept `sd-id128`, dont l'ID machine). More...

struct	AirInstant
	Instant monotone POD ABI C — nanosecondes depuis l'époque (arbitraire) de l'horloge `CLOCK_MONOTONIC`, lues via [`air_instant_now`]. More...

struct	AirDuration
	Durée non négative POD ABI C, façon `struct timespec` : une composante secondes (`i64`) et un reste sous-seconde en nanosecondes (`u32`, dans `[0, 1_000_000_000)`). More...

struct	AirDateTimeParts
	Date-heure calendaire décomposée, POD ABI C façon `struct tm`. More...

Macros
#define	AIR_UUID_HYPHENATED_LEN 37
	Taille minimale du buffer pour la forme hyphénée d'un UUID : 36 caractères `8-4-4-4-12` + l'octet `NUL` final.

#define	AIR_ID128_HEX_LEN 33
	Taille minimale du buffer pour la forme hexadécimale d'un [`AirId128`] : 32 chiffres + l'octet `NUL` final.

Typedefs
typedef struct AirByteIter	AirByteIter
	Itérateur d'octets opaque possédé à snapshot eager — handle ABI C (jamais déréférencé côté C ; `typedef struct AirByteIter AirByteIter;`).

typedef struct AirLocale	AirLocale
	Locale BCP 47 — handle opaque ABI C (jamais déréférencé côté C ; `typedef struct AirLocale AirLocale;`).

typedef struct AirLog	AirLog
	Logger structuré vers journald — handle opaque ABI C (jamais déréférencé côté C ; `typedef struct AirLog AirLog;`).

typedef struct AirLogFields	AirLogFields
	Builder de champs structurés (clé/valeur) — handle opaque ABI C (`typedef struct AirLogFields AirLogFields;`).

typedef struct AirPath	AirPath
	Chemin de fichier — handle opaque ABI C (jamais déréférencé côté C ; `typedef struct AirPath AirPath;`).

typedef struct AirString	AirString
	Chaîne UTF-8 valide, Unicode-aware — handle opaque ABI C (jamais déréférencé côté C ; `typedef struct AirString AirString;`).

Enumerations
enum	AirCalendar { AIR_CALENDAR_GREGORIAN = 0 , AIR_CALENDAR_BUDDHIST = 1 , AIR_CALENDAR_JAPANESE = 2 , AIR_CALENDAR_ISLAMIC = 3 , AIR_CALENDAR_HEBREW = 4 , AIR_CALENDAR_PERSIAN = 5 }
	Calendrier d'interprétation des composantes de date, POD ABI C — miroir `#[repr(C)]` d'[`air_base_lib::AirCalendar`] (ADR-016). More...

enum	AirLogLevel { AIR_LOG_LEVEL_EMERGENCY = 0 , AIR_LOG_LEVEL_ALERT = 1 , AIR_LOG_LEVEL_CRITICAL = 2 , AIR_LOG_LEVEL_ERROR = 3 , AIR_LOG_LEVEL_WARNING = 4 , AIR_LOG_LEVEL_NOTICE = 5 , AIR_LOG_LEVEL_INFO = 6 , AIR_LOG_LEVEL_DEBUG = 7 }
	Niveau de priorité d'une entrée de log, POD ABI C (syslog/journald `0..=7`). More...

enum	AirNormalizationForm { AIR_NORMALIZATION_FORM_NFC = 0 , AIR_NORMALIZATION_FORM_NFD = 1 , AIR_NORMALIZATION_FORM_NFKC = 2 , AIR_NORMALIZATION_FORM_NFKD = 3 }
	Forme de normalisation Unicode (Unicode Annex #15), POD ABI C — miroir `#[repr(C)]` d'[`air_base_lib::NormalizationForm`]. More...

enum	AirStatus { AIR_STATUS_OK = 0 , AIR_STATUS_NOT_FOUND = 1 , AIR_STATUS_PERMISSION_DENIED = 2 , AIR_STATUS_ALREADY_EXISTS = 3 , AIR_STATUS_INVALID_INPUT = 4 , AIR_STATUS_INTERRUPTED = 5 , AIR_STATUS_WOULD_BLOCK = 6 , AIR_STATUS_UNSUPPORTED = 7 , AIR_STATUS_TIMED_OUT = 8 , AIR_STATUS_OUT_OF_MEMORY = 9 , AIR_STATUS_BROKEN_RESOURCE = 10 , AIR_STATUS_IO = 11 , AIR_STATUS_INVALID_DATA = 12 , AIR_STATUS_OTHER = 13 , AIR_STATUS_NULL_ARGUMENT = 100 , AIR_STATUS_BUFFER_TOO_SMALL = 101 }
	Statut d'une opération de la frontière ABI C, rendu in-band (valeur de retour) — modèle d'erreurs sans `errno` d'[ADR-045]. More...

Functions
enum AirStatus	air_uuid_new_v7 (struct AirUuid *out)
	Génère un UUID v7 (ordonné dans le temps) et l'écrit dans `out`.

enum AirStatus	air_uuid_new_v4 (struct AirUuid *out)
	Génère un UUID v4 (128 bits d'aléa) et l'écrit dans `out`.

enum AirStatus	air_uuid_to_hyphenated (const struct AirUuid uuid, char buf, size_t len)
	Écrit la forme canonique hyphénée `8-4-4-4-12` (36 caractères + `NUL`) de `uuid` dans le buffer `buf` de capacité `len`.

enum AirStatus	air_uuid_parse (const char s, struct AirUuid out)
	Analyse la forme canonique `8-4-4-4-12` depuis la chaîne C `s` et écrit l'`AirUuid` résultant dans `out`.

enum AirStatus	air_id128_machine_id (struct AirId128 *out)
	Lit l'ID machine (`/etc/machine-id`) et l'écrit dans `out`.

enum AirStatus	air_id128_to_hex (const struct AirId128 id, char buf, size_t len)
	Écrit les 32 chiffres hexadécimaux minuscules (+ `NUL`) de `id` dans le buffer `buf` de capacité `len`.

enum AirStatus	air_monotonic_id_next (uint64_t *out)
	Écrit le prochain identifiant monotone local au processus (strictement croissant) dans `out`.

const char *	air_status_message (enum AirStatus status)
	Rend un message humain statique (façon `strerror`, sans locale ni état global) décrivant `status`.

enum AirStatus	air_log_open (const char namespace_, struct AirLog *out)
	Ouvre un logger vers journald dans le namespace `namespace_` (`NULL` = journal par défaut) et écrit le handle possédé dans `*out`.

void	air_log_close (struct AirLog *log)
	Ferme et libère un logger ouvert par [`air_log_open`] (ferme le socket).

enum AirStatus	air_log_emit (const struct AirLog log, enum AirLogLevel level, const char message, const struct AirLogFields *fields)
	Émet une entrée de log : `PRIORITY` (dérivé de `level`), `MESSAGE`, puis les champs `fields`.

enum AirStatus	air_log_lost_count (const struct AirLog log, uint64_t out)
	Écrit dans `*out` le nombre d'entrées perdues (journald injoignable) depuis l'ouverture de `log`.

enum AirStatus	air_log_fields_new (struct AirLogFields **out)
	Crée un builder de champs vide et écrit le handle possédé dans `*out`.

void	air_log_fields_free (struct AirLogFields *fields)
	Libère un builder de champs créé par [`air_log_fields_new`].

enum AirStatus	air_log_fields_add (struct AirLogFields fields, const char key, const char *value)
	Ajoute un champ texte `key=value` au builder.

enum AirStatus	air_log_fields_add_bytes (struct AirLogFields fields, const char key, const uint8_t *value, size_t len)
	Ajoute un champ binaire `key` ↦ `len` octets bruts (sauts de ligne et `NUL` autorisés dans la valeur — forme binaire journald à l'encodage).

enum AirStatus	air_instant_now (struct AirInstant *out)
	Lit l'instant monotone courant (`CLOCK_MONOTONIC`, couche 0) et l'écrit dans `out`.

enum AirStatus	air_instant_elapsed (const struct AirInstant since, struct AirDuration out)
	Écrit dans `out` la durée écoulée entre `since` et maintenant* (`now - since`), saturée à zéro* si `*since` est dans le futur.

enum AirStatus	air_instant_duration_since (const struct AirInstant later, const struct AirInstant earlier, struct AirDuration *out)
	Écrit dans `out` la durée séparant `earlier` de `later` (`later - earlier`), saturée à zéro si `later` précède `earlier`.

enum AirStatus	air_duration_from_secs (uint64_t s, struct AirDuration *out)
	Construit une [`AirDuration`] depuis un nombre de secondes et l'écrit dans `out` (secondes excédant l'amplitude représentable ⇒ bornées, Principe 2).

enum AirStatus	air_duration_from_millis (uint64_t ms, struct AirDuration *out)
	Construit une [`AirDuration`] depuis un nombre de millisecondes et l'écrit dans `out`.

enum AirStatus	air_duration_from_nanos (uint64_t ns, struct AirDuration *out)
	Construit une [`AirDuration`] depuis un nombre de nanosecondes et l'écrit dans `out`.

enum AirStatus	air_duration_as_secs_f64 (const struct AirDuration d, double out)
	Rend la durée `d` en secondes flottantes* (`seconds + nanoseconds / 1e9`) et l'écrit dans `out`.

enum AirStatus	air_datetime_now_utc (enum AirCalendar cal, struct AirDateTimeParts *out)
	Lit l'instant mur courant (`CLOCK_REALTIME`, couche 0), décomposé dans le calendrier `cal`, et l'écrit dans `out`.

enum AirStatus	air_datetime_from_components (enum AirCalendar cal, int32_t year, uint8_t month, uint8_t day, uint8_t hour, uint8_t minute, uint8_t second, struct AirDateTimeParts *out)
	Construit une date-heure depuis ses composantes dans `cal`, valide et normalise, et écrit le résultat dans `out`.

enum AirStatus	air_datetime_to_calendar (const struct AirDateTimeParts in_parts, enum AirCalendar cal, struct AirDateTimeParts out)
	Convertit `in_parts` vers le calendrier `cal` (même instant*, composantes renumérotées) et écrit le résultat dans `out`.

enum AirStatus	air_datetime_add_days (const struct AirDateTimeParts in_parts, int64_t days, struct AirDateTimeParts out)
	Ajoute `days` jours (signé) à `in_parts` (arithmétique calendaire — décalage du jour absolu) et écrit le résultat dans `out`, dans le même calendrier* que l'entrée.

enum AirStatus	air_path_from_bytes (const uint8_t bytes, size_t len, struct AirPath *out)
	Construit un [`AirPath`] possédé depuis les `len` octets bruts pointés par `bytes` (jamais d'erreur de validation — un chemin Unix est une suite d'octets quelconque) et écrit le handle dans `*out`.

void	air_path_free (struct AirPath *path)
	Libère un chemin construit par [`air_path_from_bytes`] / [`air_path_join`] / [`air_path_parent`] / [`air_path_normalize_lexically`].

enum AirStatus	air_path_as_bytes (const struct AirPath path, uint8_t buf, size_t cap, size_t *written)
	Écrit les octets bruts du chemin dans le buffer appelant `buf` (capacité `cap`) et la longueur réelle dans `*written` (TOUJOURS).

enum AirStatus	air_path_to_c_string (const struct AirPath path, char buf, size_t cap, size_t *written)
	Écrit le chemin sous forme de chaîne C `NUL`-terminée (consommable par les wrappers de la couche 0, `openat`…) dans le buffer appelant `buf` (capacité `cap` octets) et la longueur totale (contenu + `NUL`) dans `*written`.

enum AirStatus	air_path_join (const struct AirPath path, const struct AirPath component, struct AirPath **out)
	Joint `component` à la fin de `path` (purement lexical) et écrit le résultat possédé dans `*out`.

enum AirStatus	air_path_parent (const struct AirPath path, struct AirPath *out)
	Écrit le parent de `path` (sans le dernier composant) dans `*out`.

enum AirStatus	air_path_file_name (const struct AirPath path, uint8_t buf, size_t cap, size_t *written)
	Écrit le dernier composant (nom de fichier) de `path`, en octets bruts, dans le buffer appelant `buf` (capacité `cap`) et sa longueur dans `*written`.

enum AirStatus	air_path_extension (const struct AirPath path, uint8_t buf, size_t cap, size_t *written)
	Écrit l'extension du nom de fichier de `path` (sans le point), en octets bruts, dans le buffer appelant `buf` (capacité `cap`) et sa longueur dans `*written`.

enum AirStatus	air_path_is_absolute (const struct AirPath path, bool out)
	Écrit dans `out` si `path` est absolu* (commence par `/`).

enum AirStatus	air_path_normalize_lexically (const struct AirPath path, struct AirPath *out)
	Normalise lexicalement `path` (résout `.`

enum AirStatus	air_locale_parse (const uint8_t tag, size_t len, struct AirLocale *out)
	Analyse un identifiant BCP 47 depuis les `len` octets pointés par `tag` (validés UTF-8 en amont) et écrit le handle possédé dans `*out`.

enum AirStatus	air_locale_root (struct AirLocale **out)
	Construit la locale racine « und » (undetermined, neutre) et écrit le handle possédé dans `*out`.

enum AirStatus	air_locale_to_bcp47 (const struct AirLocale loc, uint8_t buf, size_t cap, size_t *written)
	Écrit l'identifiant BCP 47 canonique de `loc`, en octets UTF-8, dans le buffer appelant `buf` (capacité `cap`) et sa longueur dans `*written`.

enum AirStatus	air_locale_language (const struct AirLocale loc, uint8_t buf, size_t cap, size_t *written)
	Écrit la sous-étiquette de langue de `loc` (ex.

enum AirStatus	air_locale_region (const struct AirLocale loc, uint8_t buf, size_t cap, size_t *written)
	Écrit la sous-étiquette de région de `loc` (ex.

void	air_locale_free (struct AirLocale *loc)
	Libère une locale construite par [`air_locale_parse`] / [`air_locale_root`].

enum AirStatus	air_string_new (struct AirString **out)
	Crée une chaîne vide et écrit le handle possédé dans `*out`.

enum AirStatus	air_string_from_utf8 (const uint8_t bytes, size_t len, struct AirString *out)
	Construit une chaîne depuis les `len` octets pointés par `bytes`, en validant l'UTF-8 (Principe 3), et écrit le handle possédé dans `*out`.

enum AirStatus	air_string_from_utf8_lossy (const uint8_t bytes, size_t len, struct AirString *out)
	Construit une chaîne depuis les `len` octets pointés par `bytes`, en remplaçant les séquences invalides par `U+FFFD` (jamais d'erreur), et écrit le handle possédé dans `*out`.

enum AirStatus	air_string_as_bytes (const struct AirString s, uint8_t buf, size_t cap, size_t *written)
	Écrit les octets UTF-8 de `s` dans le buffer appelant `buf` (capacité `cap`) et la longueur réelle dans `*written` (TOUJOURS).

enum AirStatus	air_string_len (const struct AirString s, size_t out)
	Écrit la longueur en octets (UTF-8) de `s` dans `*out`.

enum AirStatus	air_string_normalize (const struct AirString s, enum AirNormalizationForm form, struct AirString *out)
	Normalise `s` dans la forme `form` (NFC/NFD/NFKC/NFKD) et écrit le résultat possédé dans `*out`.

enum AirStatus	air_string_is_normalized (const struct AirString s, enum AirNormalizationForm form, bool out)
	Écrit dans `out` si `s` est déjà normalisée* dans la forme `form`.

enum AirStatus	air_string_to_uppercase_in_locale (const struct AirString s, const struct AirLocale loc, struct AirString **out)
	Rend `s` en majuscules selon les règles de `loc` (ex.

enum AirStatus	air_string_to_lowercase_in_locale (const struct AirString s, const struct AirLocale loc, struct AirString **out)
	Rend `s` en minuscules selon les règles de `loc` et écrit le résultat possédé dans `*out`.

enum AirStatus	air_string_to_titlecase_in_locale (const struct AirString s, const struct AirLocale loc, struct AirString **out)
	Rend `s` en casse de titre selon les règles de `loc` et écrit le résultat possédé dans `*out`.

enum AirStatus	air_string_compare_in_locale (const struct AirString s, const struct AirString other, const struct AirLocale loc, int32_t out)
	Compare `s` et `other` selon la collation de `loc` (ex.

enum AirStatus	air_string_eq_ignore_case_in_locale (const struct AirString s, const struct AirString other, const struct AirLocale loc, bool out)
	Écrit dans `out` l'égalité insensible à la casse* de `s` et `other` selon les règles de `loc`.

enum AirStatus	air_string_grapheme_count (const struct AirString s, size_t out)
	Écrit dans `out` le nombre de clusters de graphèmes étendus* (Unicode Annex #29) de `s`.

void	air_string_free (struct AirString *s)
	Libère une chaîne construite par un constructeur ou une transformation `air_string_*` (ou un pont `air_path_to_air_string{,_lossy}`).

enum AirStatus	air_path_to_air_string (const struct AirPath p, struct AirString *out)
	Convertit `p` en [`AirString`] si le chemin est de l'UTF-8 valide et écrit le handle possédé dans `*out`.

enum AirStatus	air_path_to_air_string_lossy (const struct AirPath p, struct AirString *out)
	Convertit `p` en [`AirString`] en remplaçant les octets non-UTF-8 par `U+FFFD` (jamais d'erreur) et écrit le handle possédé dans `*out`.

enum AirStatus	air_path_from_air_string (const struct AirString s, struct AirPath *out)
	Construit un [`AirPath`] depuis `s` (UTF-8 → octets) et écrit le handle possédé dans `*out`.

enum AirStatus	air_string_graphemes (const struct AirString s, struct AirByteIter *out)
	Crée un [`AirByteIter`] sur les clusters de graphèmes étendus (UAX #29) de `s` (snapshot eager) et écrit le handle possédé dans `*out`.

enum AirStatus	air_string_words (const struct AirString s, struct AirByteIter *out)
	Crée un [`AirByteIter`] sur les mots (segmentation Unicode) de `s` (snapshot eager) et écrit le handle possédé dans `*out`.

enum AirStatus	air_string_sentences (const struct AirString s, struct AirByteIter *out)
	Crée un [`AirByteIter`] sur les phrases (segmentation Unicode) de `s` (snapshot eager) et écrit le handle possédé dans `*out`.

enum AirStatus	air_path_components (const struct AirPath p, struct AirByteIter *out)
	Crée un [`AirByteIter`] sur les composants de `p` (segments non vides séparés par `/`, octets potentiellement non-UTF-8 ; snapshot eager) et écrit le handle possédé dans `*out`.

enum AirStatus	air_byte_iter_next (struct AirByteIter it, uint8_t buf, size_t cap, size_t written, bool has_value)
	Avance l'itérateur `it` d'un cran (idiome two-call : sonder la taille, puis copier) en écrivant le prochain segment dans le buffer octets `buf` de capacité `cap`.

void	air_byte_iter_free (struct AirByteIter *it)
	Libère un itérateur créé par [`air_string_graphemes`] / [`air_string_words`] / [`air_string_sentences`] / [`air_path_components`].

Macro Definition Documentation

◆ AIR_ID128_HEX_LEN

#define AIR_ID128_HEX_LEN 33

Taille minimale du buffer pour la forme hexadécimale d'un [AirId128] : 32 chiffres + l'octet NUL final.

◆ AIR_UUID_HYPHENATED_LEN

#define AIR_UUID_HYPHENATED_LEN 37

Taille minimale du buffer pour la forme hyphénée d'un UUID : 36 caractères 8-4-4-4-12 + l'octet NUL final.

Typedef Documentation

◆ AirByteIter

typedef struct AirByteIter AirByteIter

Itérateur d'octets opaque possédé à snapshot eager — handle ABI C (jamais déréférencé côté C ; typedef struct AirByteIter AirByteIter;).

Produit par [air_string_graphemes] / [air_string_words] / [air_string_sentences] (segments UTF-8) et [air_path_components] (segments d'octets), avancé par [air_byte_iter_next], libéré par [air_byte_iter_free].

Snapshot à la création (indépendance de la source)

Tous les segments sont copiés dans ce handle à la construction : la source (AirString / AirPath) peut être mutée ou libérée ensuite sans affecter l'itération en cours. L'itérateur ne conserve aucun pointeur vers la source.

Thread-safety (ADR-027 §B.4) — possédé, non partagé

[air_byte_iter_next] mute le curseur : prévoir un itérateur par thread. Ne pas partager un même AirByteIter * entre threads sans synchronisation externe ; [air_byte_iter_free] consomme le handle.

◆ AirLocale

typedef struct AirLocale AirLocale

Locale BCP 47 — handle opaque ABI C (jamais déréférencé côté C ; typedef struct AirLocale AirLocale;).

Enveloppe possédée d'[air_base_lib::AirLocale] : un identifiant de langue ("fr-FR", "zh-Hans", "ar"). Construit par [air_locale_parse] / [air_locale_root], libéré par [air_locale_free].

Thread-safety (ADR-027 §B.4) — possédé, non partagé

Un handle appartient à un propriétaire : prévoir un handle par thread. Les accesseurs n'empruntent qu'en lecture, mais [air_locale_free] consomme le handle et exige l'absence d'usage concurrent.

◆ AirLog

typedef struct AirLog AirLog

Logger structuré vers journald — handle opaque ABI C (jamais déréférencé côté C ; typedef struct AirLog AirLog;).

Enveloppe possédée d'[air_base_lib::AirLog] (cœur Arc<JournalSink>). Ouvert par [air_log_open], libéré par [air_log_close].

Thread-safety (ADR-027 §B.4) — ThreadSafe

[air_log_emit]/[air_log_lost_count] sont sûrs depuis plusieurs threads sur le même handle (cœur Arc + envoi datagramme atomique). [air_log_close] consomme le handle : il exige l'absence d'usage concurrent.

◆ AirLogFields

typedef struct AirLogFields AirLogFields

Builder de champs structurés (clé/valeur) — handle opaque ABI C (typedef struct AirLogFields AirLogFields;).

Enveloppe possédée d'[air_base_lib::AirLogFields]. Créé par [air_log_fields_new], libéré par [air_log_fields_free], peuplé par [air_log_fields_add]/[air_log_fields_add_bytes].

Thread-safety (ADR-027 §B.4) — non thread-safe

Muté par add : le construire sur un thread, puis le passer (emprunté en lecture) à [air_log_emit]. Aucun accès concurrent au même handle.

◆ AirPath

typedef struct AirPath AirPath

Chemin de fichier — handle opaque ABI C (jamais déréférencé côté C ; typedef struct AirPath AirPath;).

Enveloppe possédée d'[air_base_lib::AirPath] : une suite d'octets pouvant contenir du non-UTF-8 (chemins Unix, Principe 3). Manipulation purement lexicale (aucun accès disque). Construit par [air_path_from_bytes] / [air_path_join] / [air_path_parent] / [air_path_normalize_lexically], libéré par [air_path_free].

Thread-safety (ADR-027 §B.4) — possédé, non partagé

Un handle appartient à un propriétaire : prévoir un handle par thread. Les accesseurs (as_bytes, file_name, …) n'empruntent qu'en lecture, mais [air_path_free] consomme le handle et exige l'absence d'usage concurrent (ne pas partager un même AirPath * entre threads sans synchronisation externe).

◆ AirString

typedef struct AirString AirString

Chaîne UTF-8 valide, Unicode-aware — handle opaque ABI C (jamais déréférencé côté C ; typedef struct AirString AirString;).

Enveloppe possédée d'[air_base_lib::AirString] : invariant UTF-8 valide par construction (le seul point d'entrée faillible est [air_string_from_utf8]). Sorties de contenu en octets (uint8_t *), le texte pouvant excéder l'ASCII. Construite par [air_string_new] / [air_string_from_utf8] / [air_string_from_utf8_lossy] / les transformations (normalize, casing) et les ponts depuis [AirPath] ; libérée par [air_string_free].

Thread-safety (ADR-027 §B.4) — possédé, non partagé

Un handle appartient à un propriétaire : prévoir un handle par thread. Les accesseurs n'empruntent qu'en lecture, mais [air_string_free] consomme le handle et exige l'absence d'usage concurrent.

Enumeration Type Documentation

◆ AirCalendar

enum AirCalendar

Calendrier d'interprétation des composantes de date, POD ABI C — miroir #[repr(C)] d'[air_base_lib::AirCalendar] (ADR-016).

Discriminants explicites et committés (stabilité ABI, ADR-012). La couche 1 marque son AirCalendar #[non_exhaustive] : d'autres calendriers pourront être ajoutés sans rupture. Un consommateur C doit rester défensif — ne pas présumer qu'une valeur reçue appartient à cette liste figée, et tolérer une variante future inconnue (p. ex. via un default: dans un switch). Le formatage localisé (ères japonaises, mois hébraïques…) relève de la couche 2 (ADR-016) : ici, seules les composantes numériques.

Propriété (ADR-027 §B)

POD trivialement copiable passé par valeur : aucune allocation, aucune fonction de libération.

Enumerator
AIR_CALENDAR_GREGORIAN	Calendrier grégorien (par défaut).
AIR_CALENDAR_BUDDHIST	Calendrier bouddhiste.
AIR_CALENDAR_JAPANESE	Calendrier japonais (ères ; composantes numériques = grégorien CE en couche 1).
AIR_CALENDAR_ISLAMIC	Calendrier islamique (hégirien, umm al-qura).
AIR_CALENDAR_HEBREW	Calendrier hébraïque.
AIR_CALENDAR_PERSIAN	Calendrier persan (solaire hégirien).

◆ AirLogLevel

enum AirLogLevel

Niveau de priorité d'une entrée de log, POD ABI C (syslog/journald 0..=7).

Miroir #[repr(C)] d'[air_base_lib::AirLogLevel] : discriminants explicites et committés (stabilité ABI, ADR-012), d'[AirLogLevel::Emergency] (0, le plus grave) à [AirLogLevel::Debug] (7, le moins grave).

Propriété (ADR-027 §B)

POD trivialement copiable passé par valeur : aucune allocation, aucune fonction de libération.

Enumerator
AIR_LOG_LEVEL_EMERGENCY	`0` — le système est inutilisable.
AIR_LOG_LEVEL_ALERT	`1` — action immédiate requise.
AIR_LOG_LEVEL_CRITICAL	`2` — condition critique.
AIR_LOG_LEVEL_ERROR	`3` — condition d'erreur.
AIR_LOG_LEVEL_WARNING	`4` — condition d'avertissement.
AIR_LOG_LEVEL_NOTICE	`5` — condition normale mais notable.
AIR_LOG_LEVEL_INFO	`6` — message d'information.
AIR_LOG_LEVEL_DEBUG	`7` — message de débogage.

◆ AirNormalizationForm

enum AirNormalizationForm

Forme de normalisation Unicode (Unicode Annex #15), POD ABI C — miroir #[repr(C)] d'[air_base_lib::NormalizationForm].

Discriminants explicites et committés (stabilité ABI 10 ans, ADR-012), passés par valeur (POD trivial : aucune allocation, aucune libération).

Enumerator
AIR_NORMALIZATION_FORM_NFC	Forme canonique composée (NFC).
AIR_NORMALIZATION_FORM_NFD	Forme canonique décomposée (NFD).
AIR_NORMALIZATION_FORM_NFKC	Forme de compatibilité composée (NFKC).
AIR_NORMALIZATION_FORM_NFKD	Forme de compatibilité décomposée (NFKD).

◆ AirStatus

enum AirStatus

Statut d'une opération de la frontière ABI C, rendu in-band (valeur de retour) — modèle d'erreurs sans errno d'[ADR-045].

AIR_STATUS_OK = 0 ; les variantes 1..=13 reflètent AirErrorKind d'air-base-lib ; 100/101 sont les codes propres à la frontière C. Discriminants explicites et committés (stabilité ABI 10 ans, ADR-012).

Enumerator
AIR_STATUS_OK	Succès. Seul cas où un `*out` est écrit.
AIR_STATUS_NOT_FOUND	Ressource introuvable (`AirErrorKind::NotFound`).
AIR_STATUS_PERMISSION_DENIED	Permission refusée (`AirErrorKind::PermissionDenied`).
AIR_STATUS_ALREADY_EXISTS	La ressource existe déjà (`AirErrorKind::AlreadyExists`).
AIR_STATUS_INVALID_INPUT	Entrée invalide (`AirErrorKind::InvalidInput`).
AIR_STATUS_INTERRUPTED	Opération interrompue (`AirErrorKind::Interrupted`).
AIR_STATUS_WOULD_BLOCK	L'opération bloquerait (`AirErrorKind::WouldBlock`).
AIR_STATUS_UNSUPPORTED	Opération non supportée (`AirErrorKind::Unsupported`).
AIR_STATUS_TIMED_OUT	Délai dépassé (`AirErrorKind::TimedOut`).
AIR_STATUS_OUT_OF_MEMORY	Mémoire insuffisante (`AirErrorKind::OutOfMemory`).
AIR_STATUS_BROKEN_RESOURCE	Ressource rompue (`AirErrorKind::BrokenResource`).
AIR_STATUS_IO	Erreur d'entrée/sortie (`AirErrorKind::Io`).
AIR_STATUS_INVALID_DATA	Données mal formées (`AirErrorKind::InvalidData`).
AIR_STATUS_OTHER	Catégorie non classée ailleurs (`AirErrorKind::Other`).
AIR_STATUS_NULL_ARGUMENT	Pointeur requis `NULL` — détecté en validation amont, sans déréférencement (code de frontière, ADR-045).
AIR_STATUS_BUFFER_TOO_SMALL	Buffer fourni par l'appelant trop petit pour la sortie (code de frontière). Aucune troncature silencieuse (ADR-032).

Function Documentation

◆ air_byte_iter_free()

void air_byte_iter_free ( struct AirByteIter * it )

Libère un itérateur créé par [air_string_graphemes] / [air_string_words] / [air_string_sentences] / [air_path_components].

Propriété (ADR-027 §B)

Consomme it (+1 → libéré) : c'est la fonction de libération des constructeurs d'AirByteIter. NULL ⇒ no-op. Après l'appel, it est invalide (ne plus l'utiliser ; pas de double-libération).

Safety

it doit être NULL (no-op) ou un pointeur issu d'un constructeur air_* d'itérateur réussi, non encore libéré, sans usage concurrent.

◆ air_byte_iter_next()

enum AirStatus air_byte_iter_next	(	struct AirByteIter *	it,
		uint8_t *	buf,
		size_t	cap,
		size_t *	written,
		bool *	has_value
	)

Avance l'itérateur it d'un cran (idiome two-call : sonder la taille, puis copier) en écrivant le prochain segment dans le buffer octets buf de capacité cap.

Cas (tous in-band, jamais de panique) :

Épuisé ⇒ *has_value = false, *written = 0, AIR_STATUS_OK.
Le segment tient (cap >= longueur) ⇒ octets copiés, *written = longueur, *has_value = true, le curseur avance, AIR_STATUS_OK.
Buffer trop petit (cap < longueur) ⇒ *written = longueur requise, *has_value = true, le curseur n'avance PAS (l'appelant agrandit buf et rappelle sur le même élément), AIR_STATUS_BUFFER_TOO_SMALL (ADR-032 : aucune troncature ni copie partielle).

cap == 0 est autorisé (sondage de taille pur) : buf peut alors être NULL. Dès que cap != 0, buf doit être non-NULL.

Propriété (ADR-027 §B)

it emprunté en mutation (+0 ; le curseur est l'unique état muté). buf possédé par l'appelant (+0). written/has_value empruntés (+0, écrits sauf erreur amont NULL). Aucune libération propre ici.

Thread-safety

AirByteIter est non thread-safe (curseur muté) : un itérateur par thread.

Retour

AIR_STATUS_OK ; AIR_STATUS_BUFFER_TOO_SMALL (buffer trop petit, sans avancer) ; AIR_STATUS_NULL_ARGUMENT si it, written ou has_value est NULL, ou si buf est NULL alors que cap != 0.

Safety

it doit être NULL (géré) ou un pointeur valide vers un AirByteIter vivant non partagé ; buf doit être NULL (géré si cap == 0) ou pointer une zone inscriptible d'au moins cap octets ; written doit être NULL (géré) ou un pointeur valide, aligné et inscriptible vers un size_t ; has_value doit être NULL (géré) ou un pointeur valide, aligné et inscriptible vers un bool.

◆ air_datetime_add_days()

enum AirStatus air_datetime_add_days	(	const struct AirDateTimeParts *	in_parts,
		int64_t	days,
		struct AirDateTimeParts *	out
	)

Ajoute days jours (signé) à *in_parts (arithmétique calendaire — décalage du jour absolu) et écrit le résultat dans out, dans le même calendrier que l'entrée.

*in_parts est revalidé ; un débordement du jour absolu (i64) ou des composantes invalides ⇒ AIR_STATUS_INVALID_INPUT.

Propriété (ADR-027 §B)

in_parts emprunté (+0, lu seulement). out emprunté (+0), écrit uniquement sur AIR_STATUS_OK. days par valeur. Aucune libération.

Thread-safety (ADR-027 §B.4) — réentrante / thread-safe

Pur calcul sur des POD locaux à l'appelant, sans état partagé ni syscall.

Retour

AIR_STATUS_OK ; AIR_STATUS_NULL_ARGUMENT si in_parts ou out est NULL ; AIR_STATUS_INVALID_INPUT si *in_parts est invalide ou si l'ajout déborde.

Safety

in_parts doit être NULL (géré) ou un pointeur valide et aligné vers un AirDateTimeParts lisible ; out doit être NULL (géré) ou un pointeur valide, aligné et inscriptible vers un AirDateTimeParts.

◆ air_datetime_from_components()

enum AirStatus air_datetime_from_components	(	enum AirCalendar	cal,
		int32_t	year,
		uint8_t	month,
		uint8_t	day,
		uint8_t	hour,
		uint8_t	minute,
		uint8_t	second,
		struct AirDateTimeParts *	out
	)

Construit une date-heure depuis ses composantes dans cal, valide et normalise, et écrit le résultat dans out.

Une date invalide (p. ex. 30 février) ou des composantes horaires hors plage ⇒ AIR_STATUS_INVALID_INPUT (rien n'est écrit, Principe 4).

Propriété (ADR-027 §B)

out emprunté (+0), écrit uniquement sur AIR_STATUS_OK. cal et les composantes passés par valeur. Aucune fonction de libération.

Thread-safety (ADR-027 §B.4) — réentrante / thread-safe

Pur calcul calendaire (via icu4x), sans état partagé ni syscall.

Retour

AIR_STATUS_OK ; AIR_STATUS_NULL_ARGUMENT si out est NULL ; AIR_STATUS_INVALID_INPUT si la date/heure est invalide dans cal.

Safety

out doit être NULL (géré) ou un pointeur valide, aligné et inscriptible vers un AirDateTimeParts.

◆ air_datetime_now_utc()

enum AirStatus air_datetime_now_utc	(	enum AirCalendar	cal,
		struct AirDateTimeParts *	out
	)

Lit l'instant mur courant (CLOCK_REALTIME, couche 0), décomposé dans le calendrier cal, et l'écrit dans out.

Propriété (ADR-027 §B)

out est emprunté (+0) : POD possédé par l'appelant, écrit uniquement sur AIR_STATUS_OK. cal passé par valeur. Aucune fonction de libération.

Thread-safety (ADR-027 §B.4) — réentrante / thread-safe

Fonction sans état partagé : lecture d'horloge kernel + écriture dans out (local à l'appelant). Sûre d'appel concurrent depuis plusieurs threads (chacun avec son propre out).

Retour

AIR_STATUS_OK, ou AIR_STATUS_NULL_ARGUMENT si out est NULL, ou le miroir de l'erreur d'horloge d'air-base-lib.

Safety

out doit être NULL (géré → AIR_STATUS_NULL_ARGUMENT) ou un pointeur valide, aligné et inscriptible vers un AirDateTimeParts.

◆ air_datetime_to_calendar()

enum AirStatus air_datetime_to_calendar	(	const struct AirDateTimeParts *	in_parts,
		enum AirCalendar	cal,
		struct AirDateTimeParts *	out
	)

Convertit *in_parts vers le calendrier cal (même instant, composantes renumérotées) et écrit le résultat dans out.

*in_parts est d'abord revalidé (reconstruction via from_components) : des composantes invalides ⇒ AIR_STATUS_INVALID_INPUT.

Propriété (ADR-027 §B)

in_parts emprunté (+0, lu seulement). out emprunté (+0), écrit uniquement sur AIR_STATUS_OK. cal par valeur. Aucune libération.

Thread-safety (ADR-027 §B.4) — réentrante / thread-safe

Pur calcul sur des POD locaux à l'appelant, sans état partagé ni syscall.

Retour

AIR_STATUS_OK ; AIR_STATUS_NULL_ARGUMENT si in_parts ou out est NULL ; AIR_STATUS_INVALID_INPUT si *in_parts n'est pas une date valide.

Safety

in_parts doit être NULL (géré) ou un pointeur valide et aligné vers un AirDateTimeParts lisible ; out doit être NULL (géré) ou un pointeur valide, aligné et inscriptible vers un AirDateTimeParts.

◆ air_duration_as_secs_f64()

enum AirStatus air_duration_as_secs_f64	(	const struct AirDuration *	d,
		double *	out
	)

Rend la durée *d en secondes flottantes (seconds + nanoseconds / 1e9) et l'écrit dans out.

Propriété (ADR-027 §B)

d et out empruntés (+0 ; d lu seulement, out écrit uniquement sur AIR_STATUS_OK). Aucune fonction de libération.

Thread-safety (ADR-027 §B.4) — réentrante / thread-safe

Pur calcul sur des POD locaux à l'appelant, sans état partagé.

Retour

AIR_STATUS_OK, ou AIR_STATUS_NULL_ARGUMENT si d ou out est NULL.

Safety

d doit être NULL (géré) ou un pointeur valide et aligné vers un AirDuration lisible ; out doit être NULL (géré) ou un pointeur valide, aligné et inscriptible vers un double.

◆ air_duration_from_millis()

enum AirStatus air_duration_from_millis	(	uint64_t	ms,
		struct AirDuration *	out
	)

Construit une [AirDuration] depuis un nombre de millisecondes et l'écrit dans out.

Propriété (ADR-027 §B)

out emprunté (+0), écrit uniquement sur AIR_STATUS_OK. Aucune fonction de libération.

Thread-safety (ADR-027 §B.4) — réentrante / thread-safe

Pur calcul sans état partagé.

Retour

AIR_STATUS_OK, ou AIR_STATUS_NULL_ARGUMENT si out est NULL.

Safety

out doit être NULL (géré) ou un pointeur valide, aligné et inscriptible vers un AirDuration.

◆ air_duration_from_nanos()

enum AirStatus air_duration_from_nanos	(	uint64_t	ns,
		struct AirDuration *	out
	)

Construit une [AirDuration] depuis un nombre de nanosecondes et l'écrit dans out.

Propriété (ADR-027 §B)

out emprunté (+0), écrit uniquement sur AIR_STATUS_OK. Aucune fonction de libération.

Thread-safety (ADR-027 §B.4) — réentrante / thread-safe

Pur calcul sans état partagé.

Retour

AIR_STATUS_OK, ou AIR_STATUS_NULL_ARGUMENT si out est NULL.

Safety

out doit être NULL (géré) ou un pointeur valide, aligné et inscriptible vers un AirDuration.

◆ air_duration_from_secs()

enum AirStatus air_duration_from_secs	(	uint64_t	s,
		struct AirDuration *	out
	)

Construit une [AirDuration] depuis un nombre de secondes et l'écrit dans out (secondes excédant l'amplitude représentable ⇒ bornées, Principe 2).

Propriété (ADR-027 §B)

out emprunté (+0), écrit uniquement sur AIR_STATUS_OK. Aucune fonction de libération.

Thread-safety (ADR-027 §B.4) — réentrante / thread-safe

Pur calcul sans état partagé.

Retour

AIR_STATUS_OK, ou AIR_STATUS_NULL_ARGUMENT si out est NULL.

Safety

out doit être NULL (géré) ou un pointeur valide, aligné et inscriptible vers un AirDuration.

◆ air_id128_machine_id()

enum AirStatus air_id128_machine_id ( struct AirId128 * out )

Lit l'ID machine (/etc/machine-id) et l'écrit dans out.

Propriété (ADR-027 §B)

out emprunté (+0), écrit uniquement sur AIR_STATUS_OK. Retour POD. Aucune fonction de libération.

Retour

AIR_STATUS_OK ; AIR_STATUS_NULL_ARGUMENT si out est NULL ; AIR_STATUS_NOT_FOUND si le fichier est absent ; AIR_STATUS_INVALID_DATA s'il est mal formé.

Safety

out doit être NULL (géré → AIR_STATUS_NULL_ARGUMENT) ou un pointeur valide, aligné et inscriptible vers un AirId128.

◆ air_id128_to_hex()

enum AirStatus air_id128_to_hex	(	const struct AirId128 *	id,
		char *	buf,
		size_t	len
	)

Écrit les 32 chiffres hexadécimaux minuscules (+ NUL) de id dans le buffer buf de capacité len.

Propriété (ADR-027 §B)

id emprunté (+0, lu seulement). buf possédé par l'appelant (+0) : Air n'alloue ni ne libère. Prévoir len >= AIR_ID128_HEX_LEN (33). Aucune fonction de libération.

Retour

AIR_STATUS_OK ; AIR_STATUS_NULL_ARGUMENT si id ou buf est NULL ; AIR_STATUS_BUFFER_TOO_SMALL si len < 33 (rien n'est écrit, ADR-032).

Safety

id doit être NULL ou un pointeur valide et aligné vers un AirId128 lisible ; buf doit être NULL ou pointer une zone inscriptible d'au moins len octets (cas NULL gérés en amont).

◆ air_instant_duration_since()

enum AirStatus air_instant_duration_since	(	const struct AirInstant *	later,
		const struct AirInstant *	earlier,
		struct AirDuration *	out
	)

Écrit dans out la durée séparant *earlier de *later (*later - *earlier), saturée à zéro si *later précède *earlier.

Propriété (ADR-027 §B)

later, earlier et out empruntés (+0 ; les deux instants lus seulement, out écrit uniquement sur AIR_STATUS_OK). Aucune fonction de libération.

Thread-safety (ADR-027 §B.4) — réentrante / thread-safe

Pur calcul sur des POD locaux à l'appelant, sans état partagé ni syscall.

Retour

AIR_STATUS_OK ; AIR_STATUS_NULL_ARGUMENT si l'un des trois pointeurs est NULL. Ne peut pas échouer autrement.

Safety

later/earlier doivent être NULL (gérés) ou des pointeurs valides et alignés vers un AirInstant lisible ; out doit être NULL (géré) ou un pointeur valide, aligné et inscriptible vers un AirDuration.

◆ air_instant_elapsed()

enum AirStatus air_instant_elapsed	(	const struct AirInstant *	since,
		struct AirDuration *	out
	)

Écrit dans out la durée écoulée entre *since et maintenant (now - *since), saturée à zéro si *since est dans le futur.

Propriété (ADR-027 §B)

since et out sont empruntés (+0 ; since lu seulement, out écrit uniquement sur AIR_STATUS_OK). Aucune fonction de libération.

Thread-safety (ADR-027 §B.4) — réentrante / thread-safe

Sans état partagé (lecture d'horloge + POD locaux à l'appelant).

Retour

AIR_STATUS_OK ; AIR_STATUS_NULL_ARGUMENT si since ou out est NULL ; le miroir de l'erreur d'horloge sinon.

Safety

since doit être NULL (géré) ou un pointeur valide et aligné vers un AirInstant lisible ; out doit être NULL (géré) ou un pointeur valide, aligné et inscriptible vers un AirDuration.

◆ air_instant_now()

enum AirStatus air_instant_now ( struct AirInstant * out )

Lit l'instant monotone courant (CLOCK_MONOTONIC, couche 0) et l'écrit dans out.

Propriété (ADR-027 §B)

out est emprunté (+0) : POD possédé par l'appelant, écrit uniquement sur AIR_STATUS_OK. Aucune fonction de libération.

Thread-safety (ADR-027 §B.4) — réentrante / thread-safe

Fonction sans état partagé : seules une lecture d'horloge kernel et une écriture dans out (local à l'appelant). Sûre d'appel concurrent depuis plusieurs threads (chacun avec son propre out).

Retour

AIR_STATUS_OK, ou AIR_STATUS_NULL_ARGUMENT si out est NULL, ou le miroir de l'erreur d'horloge d'air-base-lib.

Safety

out doit être NULL (géré → AIR_STATUS_NULL_ARGUMENT) ou un pointeur valide, aligné et inscriptible vers un AirInstant.

◆ air_locale_free()

void air_locale_free ( struct AirLocale * loc )

Libère une locale construite par [air_locale_parse] / [air_locale_root].

Propriété (ADR-027 §B)

Consomme loc (+1 → libéré) : c'est la fonction de libération des constructeurs d'AirLocale. NULL ⇒ no-op. Après l'appel, loc est invalide (ne plus l'utiliser ; pas de double-libération).

Safety

loc doit être NULL (no-op) ou un pointeur issu d'un constructeur air_locale_* réussi, non encore libéré, sans usage concurrent.

◆ air_locale_language()

enum AirStatus air_locale_language	(	const struct AirLocale *	loc,
		uint8_t *	buf,
		size_t	cap,
		size_t *	written
	)

Écrit la sous-étiquette de langue de loc (ex.

"fr"), en octets UTF-8, dans le buffer appelant buf (capacité cap) et sa longueur dans *written.

Propriété (ADR-027 §B)

loc emprunté (+0). buf possédé par l'appelant (+0). Aucune libération.

Retour

AIR_STATUS_OK ; AIR_STATUS_NULL_ARGUMENT si loc, buf ou written est NULL ; AIR_STATUS_BUFFER_TOO_SMALL si cap est insuffisante (*written = taille requise, ADR-032).

Safety

loc doit être NULL (géré) ou un pointeur valide vers un AirLocale vivant ; buf doit être NULL (géré) ou pointer une zone inscriptible d'au moins cap octets ; written doit être NULL (géré) ou un pointeur valide, aligné et inscriptible vers un size_t.

◆ air_locale_parse()

enum AirStatus air_locale_parse	(	const uint8_t *	tag,
		size_t	len,
		struct AirLocale **	out
	)

Analyse un identifiant BCP 47 depuis les len octets pointés par tag (validés UTF-8 en amont) et écrit le handle possédé dans *out.

Propriété (ADR-027 §B)

tag emprunté (+0, len octets lus seulement). *out reçoit un handle possédé par l'appelant (+1), écrit uniquement sur AIR_STATUS_OK : l'appelant doit le libérer via [air_locale_free].

Retour

AIR_STATUS_OK ; AIR_STATUS_NULL_ARGUMENT si tag ou out est NULL ; AIR_STATUS_INVALID_INPUT si tag n'est pas de l'UTF-8 (validation amont) ; AIR_STATUS_INVALID_DATA si l'identifiant est mal formé (miroir de l'erreur air-base-lib).

Safety

tag doit être NULL (géré) ou pointer une zone lisible d'au moins len octets ; out doit être NULL (géré) ou un pointeur valide, aligné et inscriptible vers un AirLocale *.

◆ air_locale_region()

enum AirStatus air_locale_region	(	const struct AirLocale *	loc,
		uint8_t *	buf,
		size_t	cap,
		size_t *	written
	)

Écrit la sous-étiquette de région de loc (ex.

"FR"), en octets UTF-8, dans le buffer appelant buf (capacité cap) et sa longueur dans *written.

Propriété (ADR-027 §B)

loc emprunté (+0). buf possédé par l'appelant (+0). Aucune libération.

Retour

AIR_STATUS_OK ; AIR_STATUS_NOT_FOUND si loc n'a pas de région (Option::None) — buf/*written non écrits ; AIR_STATUS_NULL_ARGUMENT si loc, buf ou written est NULL ; AIR_STATUS_BUFFER_TOO_SMALL si cap est insuffisante (*written = taille requise, ADR-032).

Safety

loc doit être NULL (géré) ou un pointeur valide vers un AirLocale vivant ; buf doit être NULL (géré) ou pointer une zone inscriptible d'au moins cap octets ; written doit être NULL (géré) ou un pointeur valide, aligné et inscriptible vers un size_t.

◆ air_locale_root()

enum AirStatus air_locale_root ( struct AirLocale ** out )

Construit la locale racine « und » (undetermined, neutre) et écrit le handle possédé dans *out.

Propriété (ADR-027 §B)

*out reçoit un handle possédé par l'appelant (+1), écrit uniquement sur AIR_STATUS_OK : à libérer via [air_locale_free].

Retour

AIR_STATUS_OK, ou AIR_STATUS_NULL_ARGUMENT si out est NULL.

Safety

out doit être NULL (géré) ou un pointeur valide, aligné et inscriptible vers un AirLocale *.

◆ air_locale_to_bcp47()

enum AirStatus air_locale_to_bcp47	(	const struct AirLocale *	loc,
		uint8_t *	buf,
		size_t	cap,
		size_t *	written
	)

Écrit l'identifiant BCP 47 canonique de loc, en octets UTF-8, dans le buffer appelant buf (capacité cap) et sa longueur dans *written.

Propriété (ADR-027 §B)

loc emprunté (+0). buf possédé par l'appelant (+0). Aucune libération.

Retour

AIR_STATUS_OK ; AIR_STATUS_NULL_ARGUMENT si loc, buf ou written est NULL ; AIR_STATUS_BUFFER_TOO_SMALL si cap est insuffisante (*written = taille requise, ADR-032).

Safety

loc doit être NULL (géré) ou un pointeur valide vers un AirLocale vivant ; buf doit être NULL (géré) ou pointer une zone inscriptible d'au moins cap octets ; written doit être NULL (géré) ou un pointeur valide, aligné et inscriptible vers un size_t.

◆ air_log_close()

void air_log_close ( struct AirLog * log )

Ferme et libère un logger ouvert par [air_log_open] (ferme le socket).

Propriété (ADR-027 §B)

Consomme log (+1 → libéré) : c'est la fonction de libération de [air_log_open]. NULL ⇒ no-op. Après l'appel, log est invalide (ne plus l'utiliser ; ne pas rappeler close dessus — double-libération interdite).

Safety

log doit être NULL (no-op) ou un pointeur **issu d'un [air_log_open] réussi**, non encore fermé, sans usage concurrent (la fermeture consomme).

◆ air_log_emit()

enum AirStatus air_log_emit	(	const struct AirLog *	log,
		enum AirLogLevel	level,
		const char *	message,
		const struct AirLogFields *	fields
	)

Émet une entrée de log : PRIORITY (dérivé de level), MESSAGE, puis les champs fields.

N'échoue jamais sur indisponibilité de journald (compteur de pertes interne, cf. [air_log_lost_count]).

Propriété (ADR-027 §B)

log, message et fields sont empruntés (+0, lus seulement ; aucune référence conservée au-delà de l'appel). fields NULL ⇒ aucun champ custom.

Retour

AIR_STATUS_OK ; AIR_STATUS_NULL_ARGUMENT si log ou message est NULL ; AIR_STATUS_INVALID_DATA si message n'est pas de l'UTF-8.

Safety

log doit être NULL (géré) ou un pointeur valide vers un AirLog vivant ; message doit être NULL (géré) ou une chaîne C NUL-terminée valide ; fields doit être NULL ou un pointeur valide vers un AirLogFields vivant.

◆ air_log_fields_add()

enum AirStatus air_log_fields_add	(	struct AirLogFields *	fields,
		const char *	key,
		const char *	value
	)

Ajoute un champ texte key=value au builder.

Clé non conforme à la convention journald [A-Z][A-Z0-9_]* ⇒ rejet silencieux (compté en interne ; un log ne doit jamais faire échouer l'appelant). Statut AIR_STATUS_OK dans ce cas.

Propriété (ADR-027 §B)

fields emprunté en mutation (+0). key/value empruntés (+0, NUL-terminés, lus seulement). Aucune fonction de libération propre.

Retour

AIR_STATUS_OK ; AIR_STATUS_NULL_ARGUMENT si fields, key ou value est NULL ; AIR_STATUS_INVALID_DATA si key ou value n'est pas de l'UTF-8.

Thread-safety

AirLogFields est non thread-safe : aucun accès concurrent au même handle.

Safety

fields doit être NULL (géré) ou un pointeur valide vers un AirLogFields vivant non partagé ; key/value doivent être NULL (gérés) ou des chaînes C NUL-terminées valides.

◆ air_log_fields_add_bytes()

enum AirStatus air_log_fields_add_bytes	(	struct AirLogFields *	fields,
		const char *	key,
		const uint8_t *	value,
		size_t	len
	)

Ajoute un champ binaire key ↦ len octets bruts (sauts de ligne et NUL autorisés dans la valeur — forme binaire journald à l'encodage).

Clé non conforme journald ⇒ rejet silencieux (compté ; AIR_STATUS_OK).

Propriété (ADR-027 §B)

fields emprunté en mutation (+0). key emprunté (+0, NUL-terminé). value emprunté (+0, len octets lus seulement). Aucune libération propre.

Retour

AIR_STATUS_OK ; AIR_STATUS_NULL_ARGUMENT si fields, key ou value est NULL ; AIR_STATUS_INVALID_DATA si key n'est pas de l'UTF-8.

Thread-safety

AirLogFields est non thread-safe : aucun accès concurrent au même handle.

Safety

fields doit être NULL (géré) ou un pointeur valide vers un AirLogFields vivant non partagé ; key doit être NULL (géré) ou une chaîne C NUL-terminée valide ; value doit être NULL (géré) ou pointer une zone lisible d'au moins len octets.

◆ air_log_fields_free()

void air_log_fields_free ( struct AirLogFields * fields )

Libère un builder de champs créé par [air_log_fields_new].

Propriété (ADR-027 §B)

Consomme fields (+1 → libéré) : c'est la fonction de libération de [air_log_fields_new]. NULL ⇒ no-op. Après l'appel, fields est invalide.

Safety

fields doit être NULL (no-op) ou un pointeur **issu d'un [air_log_fields_new] réussi**, non encore libéré, sans usage concurrent.

◆ air_log_fields_new()

enum AirStatus air_log_fields_new ( struct AirLogFields ** out )

Crée un builder de champs vide et écrit le handle possédé dans *out.

Propriété (ADR-027 §B)

*out reçoit un handle possédé par l'appelant (+1), écrit uniquement sur AIR_STATUS_OK : l'appelant doit le libérer via [air_log_fields_free].

Retour

AIR_STATUS_OK, ou AIR_STATUS_NULL_ARGUMENT si out est NULL.

Safety

out doit être NULL (géré → AIR_STATUS_NULL_ARGUMENT) ou un pointeur valide, aligné et inscriptible vers un AirLogFields *.

◆ air_log_lost_count()

enum AirStatus air_log_lost_count	(	const struct AirLog *	log,
		uint64_t *	out
	)

Écrit dans *out le nombre d'entrées perdues (journald injoignable) depuis l'ouverture de log.

Propriété (ADR-027 §B)

log et out empruntés (+0). *out écrit uniquement sur AIR_STATUS_OK. Aucune fonction de libération.

Retour

AIR_STATUS_OK, ou AIR_STATUS_NULL_ARGUMENT si log ou out est NULL.

Safety

log doit être NULL (géré) ou un pointeur valide vers un AirLog vivant ; out doit être NULL (géré) ou un pointeur valide, aligné et inscriptible vers un uint64_t.

◆ air_log_open()

enum AirStatus air_log_open	(	const char *	namespace_,
		struct AirLog **	out
	)

Ouvre un logger vers journald dans le namespace namespace_ (NULL = journal par défaut) et écrit le handle possédé dans *out.

Propriété (ADR-027 §B)

namespace_ emprunté (+0, NUL-terminé, lu seulement ; NULL autorisé). *out reçoit un handle possédé par l'appelant (+1), écrit uniquement sur AIR_STATUS_OK : l'appelant doit le libérer via [air_log_close].

Retour

AIR_STATUS_OK ; AIR_STATUS_NULL_ARGUMENT si out est NULL ; AIR_STATUS_INVALID_DATA si namespace_ n'est pas de l'UTF-8 ; sinon le miroir de l'erreur d'air-base-lib (namespace invalide, journald indisponible).

Safety

namespace_ doit être NULL ou un pointeur vers une chaîne C NUL-terminée valide ; out doit être NULL (géré → AIR_STATUS_NULL_ARGUMENT) ou un pointeur valide, aligné et inscriptible vers un AirLog *.

◆ air_monotonic_id_next()

enum AirStatus air_monotonic_id_next ( uint64_t * out )

Écrit le prochain identifiant monotone local au processus (strictement croissant) dans out.

Propriété (ADR-027 §B)

out emprunté (+0), écrit uniquement sur AIR_STATUS_OK. Aucune fonction de libération.

Retour

AIR_STATUS_OK, ou AIR_STATUS_NULL_ARGUMENT si out est NULL. Ne peut pas échouer autrement.

Safety

out doit être NULL (géré → AIR_STATUS_NULL_ARGUMENT) ou un pointeur valide, aligné et inscriptible vers un uint64_t.

◆ air_path_as_bytes()

enum AirStatus air_path_as_bytes	(	const struct AirPath *	path,
		uint8_t *	buf,
		size_t	cap,
		size_t *	written
	)

Écrit les octets bruts du chemin dans le buffer appelant buf (capacité cap) et la longueur réelle dans *written (TOUJOURS).

Octets bruts sans NUL terminal (le chemin peut être non-UTF-8). Pour une chaîne C consommable par la couche 0, cf. [air_path_to_c_string].

Propriété (ADR-027 §B)

path emprunté (+0, lu seulement). buf est un buffer possédé par l'appelant (+0) : Air n'alloue ni ne libère rien. Aucune libération.

Retour

AIR_STATUS_OK ; AIR_STATUS_NULL_ARGUMENT si path, buf ou written est NULL ; AIR_STATUS_BUFFER_TOO_SMALL si cap est insuffisante (rien n'est écrit dans buf, mais *written reçoit la taille requise, ADR-032).

Safety

path doit être NULL (géré) ou un pointeur valide vers un AirPath vivant ; buf doit être NULL (géré) ou pointer une zone inscriptible d'au moins cap octets ; written doit être NULL (géré) ou un pointeur valide, aligné et inscriptible vers un size_t.

◆ air_path_components()

enum AirStatus air_path_components	(	const struct AirPath *	p,
		struct AirByteIter **	out
	)

Crée un [AirByteIter] sur les composants de p (segments non vides séparés par /, octets potentiellement non-UTF-8 ; snapshot eager) et écrit le handle possédé dans *out.

Propriété (ADR-027 §B)

p emprunté (+0). *out reçoit un handle possédé (+1) sur AIR_STATUS_OK, à libérer via [air_byte_iter_free]. Indépendant de p après création (snapshot).

Retour

AIR_STATUS_OK, ou AIR_STATUS_NULL_ARGUMENT si p ou out est NULL.

Safety

p doit être NULL (géré) ou un pointeur valide vers un AirPath vivant ; out doit être NULL (géré) ou un pointeur valide, aligné et inscriptible vers un AirByteIter *.

◆ air_path_extension()

enum AirStatus air_path_extension	(	const struct AirPath *	path,
		uint8_t *	buf,
		size_t	cap,
		size_t *	written
	)

Écrit l'extension du nom de fichier de path (sans le point), en octets bruts, dans le buffer appelant buf (capacité cap) et sa longueur dans *written.

Propriété (ADR-027 §B)

path emprunté (+0). buf possédé par l'appelant (+0). Aucune libération.

Retour

AIR_STATUS_OK ; AIR_STATUS_NOT_FOUND si le nom de fichier n'a pas d'extension (pas de ., ou . en tête type .bashrc, ou pas de nom de fichier) — buf/*written non écrits ; AIR_STATUS_NULL_ARGUMENT si path, buf ou written est NULL ; AIR_STATUS_BUFFER_TOO_SMALL si cap est insuffisante (*written = taille requise, ADR-032).

Safety

path doit être NULL (géré) ou un pointeur valide vers un AirPath vivant ; buf doit être NULL (géré) ou pointer une zone inscriptible d'au moins cap octets ; written doit être NULL (géré) ou un pointeur valide, aligné et inscriptible vers un size_t.

◆ air_path_file_name()

enum AirStatus air_path_file_name	(	const struct AirPath *	path,
		uint8_t *	buf,
		size_t	cap,
		size_t *	written
	)

Écrit le dernier composant (nom de fichier) de path, en octets bruts, dans le buffer appelant buf (capacité cap) et sa longueur dans *written.

Propriété (ADR-027 §B)

path emprunté (+0). buf possédé par l'appelant (+0). Aucune libération.

Retour

AIR_STATUS_OK ; AIR_STATUS_NOT_FOUND si path n'a pas de nom de fichier (racine, vide, ou se terminant par ./..) — buf/*written non écrits ; AIR_STATUS_NULL_ARGUMENT si path, buf ou written est NULL ; AIR_STATUS_BUFFER_TOO_SMALL si cap est insuffisante (*written = taille requise, ADR-032).

Safety

path doit être NULL (géré) ou un pointeur valide vers un AirPath vivant ; buf doit être NULL (géré) ou pointer une zone inscriptible d'au moins cap octets ; written doit être NULL (géré) ou un pointeur valide, aligné et inscriptible vers un size_t.

◆ air_path_free()

void air_path_free ( struct AirPath * path )

Libère un chemin construit par [air_path_from_bytes] / [air_path_join] / [air_path_parent] / [air_path_normalize_lexically].

Propriété (ADR-027 §B)

Consomme path (+1 → libéré) : c'est la fonction de libération des constructeurs d'AirPath. NULL ⇒ no-op. Après l'appel, path est invalide (ne plus l'utiliser ; pas de double-libération).

Safety

path doit être NULL (no-op) ou un pointeur issu d'un constructeur air_path_* réussi, non encore libéré, sans usage concurrent.

◆ air_path_from_air_string()

enum AirStatus air_path_from_air_string	(	const struct AirString *	s,
		struct AirPath **	out
	)

Construit un [AirPath] depuis s (UTF-8 → octets) et écrit le handle possédé dans *out.

Propriété (ADR-027 §B)

s emprunté (+0). *out reçoit un handle possédé (+1) sur AIR_STATUS_OK, à libérer via [air_path_free].

Retour

AIR_STATUS_OK, ou AIR_STATUS_NULL_ARGUMENT si s ou out est NULL.

Safety

s doit être NULL (géré) ou un pointeur valide vers un AirString vivant ; out doit être NULL (géré) ou un pointeur valide, aligné et inscriptible vers un AirPath *.

◆ air_path_from_bytes()

enum AirStatus air_path_from_bytes	(	const uint8_t *	bytes,
		size_t	len,
		struct AirPath **	out
	)

Construit un [AirPath] possédé depuis les len octets bruts pointés par bytes (jamais d'erreur de validation — un chemin Unix est une suite d'octets quelconque) et écrit le handle dans *out.

Propriété (ADR-027 §B)

bytes emprunté (+0, len octets lus seulement). *out reçoit un handle possédé par l'appelant (+1), écrit uniquement sur AIR_STATUS_OK : l'appelant doit le libérer via [air_path_free].

Retour

AIR_STATUS_OK, ou AIR_STATUS_NULL_ARGUMENT si bytes ou out est NULL.

Safety

bytes doit être NULL (géré) ou pointer une zone lisible d'au moins len octets ; out doit être NULL (géré) ou un pointeur valide, aligné et inscriptible vers un AirPath *.

◆ air_path_is_absolute()

enum AirStatus air_path_is_absolute	(	const struct AirPath *	path,
		bool *	out
	)

Écrit dans *out si path est absolu (commence par /).

Propriété (ADR-027 §B)

path et out empruntés (+0). *out écrit uniquement sur AIR_STATUS_OK. Aucune libération.

Retour

AIR_STATUS_OK, ou AIR_STATUS_NULL_ARGUMENT si path ou out est NULL.

Safety

path doit être NULL (géré) ou un pointeur valide vers un AirPath vivant ; out doit être NULL (géré) ou un pointeur valide, aligné et inscriptible vers un bool.

◆ air_path_join()

enum AirStatus air_path_join	(	const struct AirPath *	path,
		const struct AirPath *	component,
		struct AirPath **	out
	)

Joint component à la fin de path (purement lexical) et écrit le résultat possédé dans *out.

Un component absolu (commence par /) remplace path (sémantique POSIX usuelle).

Propriété (ADR-027 §B)

path et component empruntés (+0). *out reçoit un handle possédé par l'appelant (+1), écrit uniquement sur AIR_STATUS_OK : à libérer via [air_path_free].

Retour

AIR_STATUS_OK, ou AIR_STATUS_NULL_ARGUMENT si path, component ou out est NULL.

Safety

path/component doivent être NULL (gérés) ou des pointeurs valides vers des AirPath vivants ; out doit être NULL (géré) ou un pointeur valide, aligné et inscriptible vers un AirPath *.

◆ air_path_normalize_lexically()

enum AirStatus air_path_normalize_lexically	(	const struct AirPath *	path,
		struct AirPath **	out
	)

Normalise lexicalement path (résout .

/ .. sans toucher au disque) et écrit le résultat possédé dans *out.

Propriété (ADR-027 §B)

path emprunté (+0). *out reçoit un handle possédé (+1) sur AIR_STATUS_OK, à libérer via [air_path_free].

Retour

AIR_STATUS_OK, ou AIR_STATUS_NULL_ARGUMENT si path ou out est NULL.

Safety

path doit être NULL (géré) ou un pointeur valide vers un AirPath vivant ; out doit être NULL (géré) ou un pointeur valide, aligné et inscriptible vers un AirPath *.

◆ air_path_parent()

enum AirStatus air_path_parent	(	const struct AirPath *	path,
		struct AirPath **	out
	)

Écrit le parent de path (sans le dernier composant) dans *out.

Propriété (ADR-027 §B)

path emprunté (+0). *out reçoit un handle possédé (+1) sur AIR_STATUS_OK, à libérer via [air_path_free].

Retour

AIR_STATUS_OK (parent écrit dans *out) ; AIR_STATUS_NOT_FOUND si path n'a pas de parent (racine / ou chemin vide) — *out non écrit ; AIR_STATUS_NULL_ARGUMENT si path ou out est NULL.

Safety

path doit être NULL (géré) ou un pointeur valide vers un AirPath vivant ; out doit être NULL (géré) ou un pointeur valide, aligné et inscriptible vers un AirPath *.

◆ air_path_to_air_string()

enum AirStatus air_path_to_air_string	(	const struct AirPath *	p,
		struct AirString **	out
	)

Convertit p en [AirString] si le chemin est de l'UTF-8 valide et écrit le handle possédé dans *out.

Propriété (ADR-027 §B)

p emprunté (+0). *out reçoit un handle possédé (+1) sur AIR_STATUS_OK, à libérer via [air_string_free].

Retour

AIR_STATUS_OK ; AIR_STATUS_NULL_ARGUMENT si p ou out est NULL ; AIR_STATUS_INVALID_DATA si le chemin n'est pas de l'UTF-8 (miroir de l'erreur air-base-lib ; utiliser [air_path_to_air_string_lossy] pour remplacer les octets invalides).

Safety

p doit être NULL (géré) ou un pointeur valide vers un AirPath vivant ; out doit être NULL (géré) ou un pointeur valide, aligné et inscriptible vers un AirString *.

◆ air_path_to_air_string_lossy()

enum AirStatus air_path_to_air_string_lossy	(	const struct AirPath *	p,
		struct AirString **	out
	)

Convertit p en [AirString] en remplaçant les octets non-UTF-8 par U+FFFD (jamais d'erreur) et écrit le handle possédé dans *out.

Propriété (ADR-027 §B)

p emprunté (+0). *out reçoit un handle possédé (+1) sur AIR_STATUS_OK, à libérer via [air_string_free].

Retour

AIR_STATUS_OK, ou AIR_STATUS_NULL_ARGUMENT si p ou out est NULL.

Safety

p doit être NULL (géré) ou un pointeur valide vers un AirPath vivant ; out doit être NULL (géré) ou un pointeur valide, aligné et inscriptible vers un AirString *.

◆ air_path_to_c_string()

enum AirStatus air_path_to_c_string	(	const struct AirPath *	path,
		char *	buf,
		size_t	cap,
		size_t *	written
	)

Écrit le chemin sous forme de chaîne C NUL-terminée (consommable par les wrappers de la couche 0, openat…) dans le buffer appelant buf (capacité cap octets) et la longueur totale (contenu + NUL) dans *written.

Propriété (ADR-027 §B)

path emprunté (+0). buf possédé par l'appelant (+0). Aucune libération.

Retour

AIR_STATUS_OK ; AIR_STATUS_NULL_ARGUMENT si path, buf ou written est NULL ; AIR_STATUS_INVALID_INPUT si le chemin contient un octet NUL interne (incompatible avec une chaîne C) ; AIR_STATUS_BUFFER_TOO_SMALL si cap < longueur + 1 (*written reçoit la taille requise, ADR-032).

Safety

path doit être NULL (géré) ou un pointeur valide vers un AirPath vivant ; buf doit être NULL (géré) ou pointer une zone inscriptible d'au moins cap octets ; written doit être NULL (géré) ou un pointeur valide, aligné et inscriptible vers un size_t.

◆ air_status_message()

const char * air_status_message ( enum AirStatus status )

Rend un message humain statique (façon strerror, sans locale ni état global) décrivant status.

Propriété (ADR-027 §B)

Le pointeur retourné référence une chaîne statique NUL-terminée (+0) : jamais libérée, valide pour toute la durée du programme. L'appelant ne doit pas la libérer. Jamais NULL.

Retour

Pointeur non-NULL vers une chaîne C const statique.

◆ air_string_as_bytes()

enum AirStatus air_string_as_bytes	(	const struct AirString *	s,
		uint8_t *	buf,
		size_t	cap,
		size_t *	written
	)

Écrit les octets UTF-8 de s dans le buffer appelant buf (capacité cap) et la longueur réelle dans *written (TOUJOURS).

Pas de NUL terminal (le contenu est de l'UTF-8 binaire).

Propriété (ADR-027 §B)

s emprunté (+0). buf possédé par l'appelant (+0). Aucune libération.

Retour

AIR_STATUS_OK ; AIR_STATUS_NULL_ARGUMENT si s, buf ou written est NULL ; AIR_STATUS_BUFFER_TOO_SMALL si cap est insuffisante (*written = taille requise, ADR-032).

Safety

s doit être NULL (géré) ou un pointeur valide vers un AirString vivant ; buf doit être NULL (géré) ou pointer une zone inscriptible d'au moins cap octets ; written doit être NULL (géré) ou un pointeur valide, aligné et inscriptible vers un size_t.

◆ air_string_compare_in_locale()

enum AirStatus air_string_compare_in_locale	(	const struct AirString *	s,
		const struct AirString *	other,
		const struct AirLocale *	loc,
		int32_t *	out
	)

Compare s et other selon la collation de loc (ex.

ordre des accents en fr) et écrit -1 / 0 / 1 (Less / Equal / Greater) dans *out.

Propriété (ADR-027 §B)

s, other et loc empruntés (+0). *out écrit uniquement sur AIR_STATUS_OK. Aucune libération.

Retour

AIR_STATUS_OK, ou AIR_STATUS_NULL_ARGUMENT si s, other, loc ou out est NULL.

Safety

s/other/loc doivent être NULL (gérés) ou des pointeurs valides vers un AirString / AirLocale vivants ; out doit être NULL (géré) ou un pointeur valide, aligné et inscriptible vers un int32_t.

◆ air_string_eq_ignore_case_in_locale()

enum AirStatus air_string_eq_ignore_case_in_locale	(	const struct AirString *	s,
		const struct AirString *	other,
		const struct AirLocale *	loc,
		bool *	out
	)

Écrit dans *out l'égalité insensible à la casse de s et other selon les règles de loc.

Propriété (ADR-027 §B)

s, other et loc empruntés (+0). *out écrit uniquement sur AIR_STATUS_OK. Aucune libération.

Retour

AIR_STATUS_OK, ou AIR_STATUS_NULL_ARGUMENT si s, other, loc ou out est NULL.

Safety

s/other/loc doivent être NULL (gérés) ou des pointeurs valides vers un AirString / AirLocale vivants ; out doit être NULL (géré) ou un pointeur valide, aligné et inscriptible vers un bool.

◆ air_string_free()

void air_string_free ( struct AirString * s )

Libère une chaîne construite par un constructeur ou une transformation air_string_* (ou un pont air_path_to_air_string{,_lossy}).

Propriété (ADR-027 §B)

Consomme s (+1 → libéré) : c'est la fonction de libération des constructeurs d'AirString. NULL ⇒ no-op. Après l'appel, s est invalide (ne plus l'utiliser ; pas de double-libération).

Safety

s doit être NULL (no-op) ou un pointeur issu d'un constructeur air_string_* / pont réussi, non encore libéré, sans usage concurrent.

◆ air_string_from_utf8()

enum AirStatus air_string_from_utf8	(	const uint8_t *	bytes,
		size_t	len,
		struct AirString **	out
	)

Construit une chaîne depuis les len octets pointés par bytes, en validant l'UTF-8 (Principe 3), et écrit le handle possédé dans *out.

Propriété (ADR-027 §B)

bytes emprunté (+0, len octets lus seulement). *out reçoit un handle possédé par l'appelant (+1), écrit uniquement sur AIR_STATUS_OK : à libérer via [air_string_free].

Retour

AIR_STATUS_OK ; AIR_STATUS_NULL_ARGUMENT si bytes ou out est NULL ; AIR_STATUS_INVALID_DATA si bytes n'est pas de l'UTF-8 valide (miroir de l'erreur air-base-lib).

Safety

bytes doit être NULL (géré) ou pointer une zone lisible d'au moins len octets ; out doit être NULL (géré) ou un pointeur valide, aligné et inscriptible vers un AirString *.

◆ air_string_from_utf8_lossy()

enum AirStatus air_string_from_utf8_lossy	(	const uint8_t *	bytes,
		size_t	len,
		struct AirString **	out
	)

Construit une chaîne depuis les len octets pointés par bytes, en remplaçant les séquences invalides par U+FFFD (jamais d'erreur), et écrit le handle possédé dans *out.

Propriété (ADR-027 §B)

bytes emprunté (+0, len octets lus seulement). *out reçoit un handle possédé par l'appelant (+1), écrit uniquement sur AIR_STATUS_OK : à libérer via [air_string_free].

Retour

AIR_STATUS_OK, ou AIR_STATUS_NULL_ARGUMENT si bytes ou out est NULL.

Safety

bytes doit être NULL (géré) ou pointer une zone lisible d'au moins len octets ; out doit être NULL (géré) ou un pointeur valide, aligné et inscriptible vers un AirString *.

◆ air_string_grapheme_count()

enum AirStatus air_string_grapheme_count	(	const struct AirString *	s,
		size_t *	out
	)

Écrit dans *out le nombre de clusters de graphèmes étendus (Unicode Annex #29) de s.

Distinct de la longueur en octets (cf. [air_string_len]) et du nombre de char : un emoji ZWJ ou une lettre accentuée combinée comptent pour un graphème.

Propriété (ADR-027 §B)

s et out empruntés (+0). *out écrit uniquement sur AIR_STATUS_OK. Aucune libération.

Retour

AIR_STATUS_OK, ou AIR_STATUS_NULL_ARGUMENT si s ou out est NULL.

Safety

s doit être NULL (géré) ou un pointeur valide vers un AirString vivant ; out doit être NULL (géré) ou un pointeur valide, aligné et inscriptible vers un size_t.

◆ air_string_graphemes()

enum AirStatus air_string_graphemes	(	const struct AirString *	s,
		struct AirByteIter **	out
	)

Crée un [AirByteIter] sur les clusters de graphèmes étendus (UAX #29) de s (snapshot eager) et écrit le handle possédé dans *out.

Propriété (ADR-027 §B)

s emprunté (+0, lu seulement le temps de la copie). *out reçoit un handle possédé par l'appelant (+1), écrit uniquement sur AIR_STATUS_OK : l'appelant doit le libérer via [air_byte_iter_free]. Le snapshot rend l'itérateur indépendant de s (libérable aussitôt après).

Retour

AIR_STATUS_OK, ou AIR_STATUS_NULL_ARGUMENT si s ou out est NULL.

Safety

s doit être NULL (géré) ou un pointeur valide vers un AirString vivant ; out doit être NULL (géré) ou un pointeur valide, aligné et inscriptible vers un AirByteIter *.

◆ air_string_is_normalized()

enum AirStatus air_string_is_normalized	(	const struct AirString *	s,
		enum AirNormalizationForm	form,
		bool *	out
	)

Écrit dans *out si s est déjà normalisée dans la forme form.

Propriété (ADR-027 §B)

s et out empruntés (+0). form POD par valeur (+0). *out écrit uniquement sur AIR_STATUS_OK. Aucune libération.

Retour

AIR_STATUS_OK, ou AIR_STATUS_NULL_ARGUMENT si s ou out est NULL.

Safety

s doit être NULL (géré) ou un pointeur valide vers un AirString vivant ; out doit être NULL (géré) ou un pointeur valide, aligné et inscriptible vers un bool.

◆ air_string_len()

enum AirStatus air_string_len	(	const struct AirString *	s,
		size_t *	out
	)

Écrit la longueur en octets (UTF-8) de s dans *out.

Distincte du nombre de char et du nombre de graphèmes (cf. [air_string_grapheme_count]).

Propriété (ADR-027 §B)

s et out empruntés (+0). *out écrit uniquement sur AIR_STATUS_OK. Aucune libération.

Retour

AIR_STATUS_OK, ou AIR_STATUS_NULL_ARGUMENT si s ou out est NULL.

Safety

s doit être NULL (géré) ou un pointeur valide vers un AirString vivant ; out doit être NULL (géré) ou un pointeur valide, aligné et inscriptible vers un size_t.

◆ air_string_new()

enum AirStatus air_string_new ( struct AirString ** out )

Crée une chaîne vide et écrit le handle possédé dans *out.

Propriété (ADR-027 §B)

*out reçoit un handle possédé par l'appelant (+1), écrit uniquement sur AIR_STATUS_OK : à libérer via [air_string_free].

Retour

AIR_STATUS_OK, ou AIR_STATUS_NULL_ARGUMENT si out est NULL.

Safety

out doit être NULL (géré) ou un pointeur valide, aligné et inscriptible vers un AirString *.

◆ air_string_normalize()

enum AirStatus air_string_normalize	(	const struct AirString *	s,
		enum AirNormalizationForm	form,
		struct AirString **	out
	)

Normalise s dans la forme form (NFC/NFD/NFKC/NFKD) et écrit le résultat possédé dans *out.

Propriété (ADR-027 §B)

s emprunté (+0). form POD passé par valeur (+0). *out reçoit un handle possédé (+1) sur AIR_STATUS_OK, à libérer via [air_string_free].

Retour

AIR_STATUS_OK, ou AIR_STATUS_NULL_ARGUMENT si s ou out est NULL.

Safety

s doit être NULL (géré) ou un pointeur valide vers un AirString vivant ; out doit être NULL (géré) ou un pointeur valide, aligné et inscriptible vers un AirString *.

◆ air_string_sentences()

enum AirStatus air_string_sentences	(	const struct AirString *	s,
		struct AirByteIter **	out
	)

Crée un [AirByteIter] sur les phrases (segmentation Unicode) de s (snapshot eager) et écrit le handle possédé dans *out.

Propriété (ADR-027 §B)

s emprunté (+0). *out reçoit un handle possédé (+1) sur AIR_STATUS_OK, à libérer via [air_byte_iter_free]. Indépendant de s après création (snapshot).

Retour

AIR_STATUS_OK, ou AIR_STATUS_NULL_ARGUMENT si s ou out est NULL.

Safety

s doit être NULL (géré) ou un pointeur valide vers un AirString vivant ; out doit être NULL (géré) ou un pointeur valide, aligné et inscriptible vers un AirByteIter *.

◆ air_string_to_lowercase_in_locale()

enum AirStatus air_string_to_lowercase_in_locale	(	const struct AirString *	s,
		const struct AirLocale *	loc,
		struct AirString **	out
	)

Rend s en minuscules selon les règles de loc et écrit le résultat possédé dans *out.

Propriété (ADR-027 §B)

s et loc empruntés (+0). *out reçoit un handle possédé (+1) sur AIR_STATUS_OK, à libérer via [air_string_free].

Retour

AIR_STATUS_OK, ou AIR_STATUS_NULL_ARGUMENT si s, loc ou out est NULL.

Safety

s/loc doivent être NULL (gérés) ou des pointeurs valides vers un AirString / AirLocale vivants ; out doit être NULL (géré) ou un pointeur valide, aligné et inscriptible vers un AirString *.

◆ air_string_to_titlecase_in_locale()

enum AirStatus air_string_to_titlecase_in_locale	(	const struct AirString *	s,
		const struct AirLocale *	loc,
		struct AirString **	out
	)

Rend s en casse de titre selon les règles de loc et écrit le résultat possédé dans *out.

Propriété (ADR-027 §B)

s et loc empruntés (+0). *out reçoit un handle possédé (+1) sur AIR_STATUS_OK, à libérer via [air_string_free].

Retour

AIR_STATUS_OK, ou AIR_STATUS_NULL_ARGUMENT si s, loc ou out est NULL.

Safety

s/loc doivent être NULL (gérés) ou des pointeurs valides vers un AirString / AirLocale vivants ; out doit être NULL (géré) ou un pointeur valide, aligné et inscriptible vers un AirString *.

◆ air_string_to_uppercase_in_locale()

enum AirStatus air_string_to_uppercase_in_locale	(	const struct AirString *	s,
		const struct AirLocale *	loc,
		struct AirString **	out
	)

Rend s en majuscules selon les règles de loc (ex.

casing turc i→İ) et écrit le résultat possédé dans *out.

Propriété (ADR-027 §B)

s et loc empruntés (+0). *out reçoit un handle possédé (+1) sur AIR_STATUS_OK, à libérer via [air_string_free].

Retour

AIR_STATUS_OK, ou AIR_STATUS_NULL_ARGUMENT si s, loc ou out est NULL.

Safety

s/loc doivent être NULL (gérés) ou des pointeurs valides vers un AirString / AirLocale vivants ; out doit être NULL (géré) ou un pointeur valide, aligné et inscriptible vers un AirString *.

◆ air_string_words()

enum AirStatus air_string_words	(	const struct AirString *	s,
		struct AirByteIter **	out
	)

Crée un [AirByteIter] sur les mots (segmentation Unicode) de s (snapshot eager) et écrit le handle possédé dans *out.

Propriété (ADR-027 §B)

s emprunté (+0). *out reçoit un handle possédé (+1) sur AIR_STATUS_OK, à libérer via [air_byte_iter_free]. Indépendant de s après création (snapshot).

Retour

AIR_STATUS_OK, ou AIR_STATUS_NULL_ARGUMENT si s ou out est NULL.

Safety

s doit être NULL (géré) ou un pointeur valide vers un AirString vivant ; out doit être NULL (géré) ou un pointeur valide, aligné et inscriptible vers un AirByteIter *.

◆ air_uuid_new_v4()

enum AirStatus air_uuid_new_v4 ( struct AirUuid * out )

Génère un UUID v4 (128 bits d'aléa) et l'écrit dans out.

Propriété (ADR-027 §B)

out emprunté (+0), écrit uniquement sur AIR_STATUS_OK. Retour POD. Aucune fonction de libération.

Retour

AIR_STATUS_OK, AIR_STATUS_NULL_ARGUMENT si out est NULL, ou le miroir de l'erreur d'entropie.

Safety

out doit être soit NULL (géré → AIR_STATUS_NULL_ARGUMENT), soit un pointeur valide, aligné et inscriptible vers un AirUuid.

◆ air_uuid_new_v7()

enum AirStatus air_uuid_new_v7 ( struct AirUuid * out )

Génère un UUID v7 (ordonné dans le temps) et l'écrit dans out.

Propriété (ADR-027 §B)

out est emprunté (+0) : POD possédé par l'appelant, écrit uniquement sur AIR_STATUS_OK. Retour par valeur ([AirStatus], POD trivial). Aucune fonction de libération.

Retour

AIR_STATUS_OK, ou AIR_STATUS_NULL_ARGUMENT si out est NULL, ou le miroir de l'erreur d'air-base-lib (entropie/horloge).

Safety

out doit être soit NULL (géré → AIR_STATUS_NULL_ARGUMENT), soit un pointeur valide, aligné et inscriptible vers un AirUuid (validation amont : aucun déréférencement d'un NULL).

◆ air_uuid_parse()

enum AirStatus air_uuid_parse	(	const char *	s,
		struct AirUuid *	out
	)

Analyse la forme canonique 8-4-4-4-12 depuis la chaîne C s et écrit l'AirUuid résultant dans out.

Propriété (ADR-027 §B)

s emprunté (+0, NUL-terminé, lu seulement). out emprunté (+0), écrit uniquement sur AIR_STATUS_OK. Aucune fonction de libération.

Retour

AIR_STATUS_OK ; AIR_STATUS_NULL_ARGUMENT si s ou out est NULL ; AIR_STATUS_INVALID_DATA si s n'est pas de l'UTF-8 ou n'est pas un UUID valide.

Safety

s doit être NULL ou un pointeur vers une chaîne C NUL-terminée valide ; out doit être NULL ou un pointeur valide, aligné et inscriptible vers un AirUuid (cas NULL gérés en amont).

◆ air_uuid_to_hyphenated()

enum AirStatus air_uuid_to_hyphenated	(	const struct AirUuid *	uuid,
		char *	buf,
		size_t	len
	)

Écrit la forme canonique hyphénée 8-4-4-4-12 (36 caractères + NUL) de uuid dans le buffer buf de capacité len.

Propriété (ADR-027 §B)

uuid emprunté (+0, lu seulement). buf est un buffer possédé par l'appelant (+0) : Air n'alloue rien et ne libère rien. Prévoir len >= AIR_UUID_HYPHENATED_LEN (37). Aucune fonction de libération.

Retour

AIR_STATUS_OK ; AIR_STATUS_NULL_ARGUMENT si uuid ou buf est NULL ; AIR_STATUS_BUFFER_TOO_SMALL si len < 37 (rien n'est écrit, ADR-032).

Safety

uuid doit être NULL ou un pointeur valide et aligné vers un AirUuid lisible ; buf doit être NULL ou pointer une zone inscriptible d'au moins len octets (les cas NULL sont gérés en amont).

Data Structures

Macros

Typedefs

Enumerations

Functions

Macro Definition Documentation

◆ AIR_ID128_HEX_LEN

◆ AIR_UUID_HYPHENATED_LEN

Typedef Documentation

◆ AirByteIter

Snapshot à la création (indépendance de la source)

Thread-safety (ADR-027 §B.4) — <strong>possédé, non partagé</strong>

◆ AirLocale

Thread-safety (ADR-027 §B.4) — <strong>possédé, non partagé</strong>

◆ AirLog

Thread-safety (ADR-027 §B.4) — <strong>ThreadSafe</strong>

◆ AirLogFields

Thread-safety (ADR-027 §B.4) — <strong>non thread-safe</strong>

◆ AirPath

Thread-safety (ADR-027 §B.4) — <strong>possédé, non partagé</strong>

◆ AirString

Thread-safety (ADR-027 §B.4) — <strong>possédé, non partagé</strong>

Enumeration Type Documentation

◆ AirCalendar

Propriété (ADR-027 §B)

◆ AirLogLevel

Propriété (ADR-027 §B)

◆ AirNormalizationForm

◆ AirStatus

Function Documentation

◆ air_byte_iter_free()

Propriété (ADR-027 §B)

Safety

◆ air_byte_iter_next()

Propriété (ADR-027 §B)

Thread-safety

Retour

Safety

◆ air_datetime_add_days()

Propriété (ADR-027 §B)

Thread-safety (ADR-027 §B.4) — <strong>réentrante / thread-safe</strong>

Retour

Safety

◆ air_datetime_from_components()

Propriété (ADR-027 §B)

Thread-safety (ADR-027 §B.4) — <strong>réentrante / thread-safe</strong>

Retour

Safety

◆ air_datetime_now_utc()

Propriété (ADR-027 §B)

Thread-safety (ADR-027 §B.4) — <strong>réentrante / thread-safe</strong>

Retour

Safety

◆ air_datetime_to_calendar()

Propriété (ADR-027 §B)

Thread-safety (ADR-027 §B.4) — <strong>réentrante / thread-safe</strong>

Retour

Safety

◆ air_duration_as_secs_f64()

Propriété (ADR-027 §B)

Thread-safety (ADR-027 §B.4) — <strong>réentrante / thread-safe</strong>

Retour

Safety

◆ air_duration_from_millis()

Propriété (ADR-027 §B)

Thread-safety (ADR-027 §B.4) — <strong>réentrante / thread-safe</strong>

Retour

Safety

◆ air_duration_from_nanos()

Propriété (ADR-027 §B)

Thread-safety (ADR-027 §B.4) — <strong>réentrante / thread-safe</strong>

Retour

Safety

◆ air_duration_from_secs()

Propriété (ADR-027 §B)

Thread-safety (ADR-027 §B.4) — <strong>réentrante / thread-safe</strong>

Retour

Safety

◆ air_id128_machine_id()

Propriété (ADR-027 §B)