Voici la liste des fonctions que propose la bibliothèque libuv :
| Nom | Description |
|---|---|
| uv_available_parallelism | Cette fonction permet d'estimer le nombre de processus léger parallèles qu'un programme peut utiliser, en tenant compte de l'affinité CPU du processus léger appelant ou du nombre de processeurs logiques disponibles. |
| uv_backend_fd | Cette fonction permet de récupérer le descripteur de fichier utilisé en interne par le backend de la boucle d'événements (epoll, kqueue ou event ports). Ce descripteur peut être utilisé pour intégrer libuv dans une autre boucle d'événements ou pour effectuer du polling dans un thread distinct. |
| uv_backend_timeout | Cette fonction permet d'obtenir le délai d'attente (en millisecondes) utilisé par le backend de la boucle d'événements lors du polling. Elle retourne -1 si aucun délai n'est défini, ce qui signifie que la boucle attend indéfiniment jusqu'à ce qu'un événement survienne. |
| uv_barrier_destroy | Cette fonction permet de détruire une barrière précédemment initialisée, libérant les ressources associées. |
| uv_barrier_init | Cette fonction permet d'initialiser une barrière de synchronisation, qui bloque les processus légers appelants jusqu'à ce qu'un nombre donné d'entre eux l'atteigne. |
| uv_barrier_wait | Cette fonction permet de faire attendre un processus léger à la barrière jusqu'à ce que le nombre total de processus légers attendus soit atteint. Un des processus légers recevra une valeur > 0 pour signaler qu'il peut procéder à la destruction de la barrière. |
| uv_buf_init | Cette fonction permet d'initialiser une structure uv_buf_t, utilisée pour les opérations de lecture et d'écriture désynchronisées. L'utilisateur est responsable de libérer la mémoire pointée par base une fois l'opération terminée. |
| uv_chdir | Cette fonction permet de changer le répertoire de travail courant du processus pour le répertoire spécifié. |
| uv_clock_gettime | Cette fonction permet d'obtenir l'heure actuelle à partir d'une source d'horloge haute résolution, soit en temps réel (référencé à l'époque UNIX), soit en temps monotone (non affecté par les ajustements système). |
| uv_cond_broadcast | Cette fonction permet de réveiller tous les processus légers en attente sur la condition spécifiée. |
| uv_cond_destroy | Cette fonction permet de détruire une variable de condition précédemment initialisée, libérant les ressources associées. |
| uv_cond_init | Cette fonction permet d'initialiser une variable de condition utilisée pour la synchronisation entre processus légers. |
| uv_cond_init | Cette fonction permet d'initialiser une variable de condition utilisée pour synchroniser des processus légers via des signaux. |
| uv_cond_signal | Cette fonction permet de réveiller un seul processus léger en attente sur la condition spécifiée. |
| uv_cond_timedwait | Cette fonction permet de mettre un processus léger en attente sur la condition spécifiée avec un délai maximal, en relâchant temporairement le mutex associé. |
| uv_cond_wait | Cette fonction permet de mettre un processus léger en attente sur la condition spécifiée, en relâchant temporairement le mutex associé. |
| uv_cpu_info | Cette fonction permet d'obtenir des informations détaillées sur chaque processeur (CPU) du système, comme la vitesse, le nombre de cours, et le temps d'utilisation. La mémoire allouée doit être libérée avec uv_free_cpu_info(). |
| uv_cpumask_size | Cette fonction permet de connaître la taille maximale du masque utilisé pour définir l'affinité des processus ou des processus légers. Elle retourne UV_ENOTSUP si l'affinité n'est pas supportée sur la plateforme. |
| uv_cwd | Cette fonction permet de récupérer le répertoire de travail courant du processus. Si le tampon est trop petit, elle retourne UV_ENOBUFS et indique la taille requise. |
| uv_default_loop | Cette fonction permet d'obtenir une boucle d'événements par défaut déjà initialisée, utilisable globalement dans une application. Bien qu'elle soit pratique, cette boucle fonctionne de la même manière que celles créées avec uv_loop_init. Il est recommandé de la fermer avec uv_loop_close une fois qu'elle n'est plus nécessaire. Attention : cette fonction n'est pas thread-safe. |
| uv_dlclose | Cette fonction permet de fermer une bibliothèque partagée précédemment ouverte avec uv_dlopen, libérant ainsi les ressources associées. |
| uv_dlopen | Cette fonction permet de charger dynamiquement une bibliothèque partagée (fichier .so, .dll,...) en mémoire, en utilisant son nom de fichier encodé en UTF-8. Elle retourne 0 en cas de succès et -1 en cas d'échec. En cas d'erreur, le message correspondant peut être récupéré avec uv_dlerror(). |
| uv_dlsym | Cette fonction permet de récupérer un pointeur vers un symbole (fonction ou variable) défini dans une bibliothèque dynamique précédemment chargée avec uv_dlopen. Elle retourne 0 si le symbole est trouvé, ou -1 sinon. |
| uv_dlerror | Cette fonction permet d'obtenir le dernier message d'erreur produit par un appel à uv_dlopen() ou uv_dlsym() ayant échoué. |
| uv_exepath | Cette fonction permet d'obtenir le chemin absolu de l'exécutable en cours d'exécution. Elle nécessite que uv_setup_args() ait été appelée au préalable. |
| uv_freeaddrinfo | Cette fonction permet de libérer la mémoire allouée à une structure addrinfo obtenue via uv_getaddrinfo. Elle prend en charge les pointeurs NULL sans provoquer d'erreur, ce qui en fait une opération sûre même si aucune mémoire n'a été allouée. |
| uv_free_cpu_info | Cette fonction permet de libérer la mémoire allouée par uv_cpu_info() pour le tableau contenant les informations des processeurs. |
| uv_free_interface_addresses | Cette fonction permet de libérer la mémoire précédemment allouée avec uv_interface_addresses(). |
| uv_fs_access | Cette fonction permet de vérifier les permissions d'accès (lecture, écriture, exécution) sur un fichier ou un répertoire donné. Elle est équivalente à access() sous Unix et utilise GetFileAttributesW() sous Windows. |
| uv_fs_chmod | Cette fonction permet de modifier les permissions d'un fichier ou d'un répertoire, de manière équivalente à l'appel système chmod(). |
| uv_fs_chown | Cette fonction permet de changer l'identifiant utilisateur (uid) et l'identifiant de groupe (gid) d'un fichier, de manière équivalente à chown(). |
| uv_fs_close | Cette fonction permet de fermer un descripteur de fichier ouvert précédemment. Elle est équivalente à l'appel système POSIX close et libère les ressources associées au fichier. |
| uv_fs_closedir | Cette fonction permet de fermer un flux de répertoire ouvert avec uv_fs_opendir() et de libérer la mémoire associée à ce flux. Elle doit être utilisée pour éviter les fuites mémoire. |
| uv_fs_copyfile | Cette fonction permet de copier un fichier d'un chemin source vers un chemin de destination, avec des options pour contrôler le comportement (exemple écrasement, copie différée en écriture). Elle utilise une approche optimisée selon la plateforme, avec possibilité de tomber en repli sur uv_fs_sendfile() si nécessaire. |
| uv_fs_fchmod | Cette fonction permet de modifier les permissions d'un fichier déjà ouvert à partir de son descripteur, comme le fait l'appel système fchmod(). |
| uv_fs_fchown | Cette fonction permet de modifier le propriétaire et le groupe associés à un descripteur de fichier, comme fchown(). |
| uv_fs_fdatasync | Cette fonction permet de forcer l'écriture sur le disque uniquement des données d'un fichier ouvert (sans les métadonnées), en s'appuyant sur l'appel système fdatasync(). |
| uv_fs_fstat | Cette fonction permet d'obtenir les métadonnées d'un fichier déjà ouvert, via son descripteur, comme avec fstat(). |
| uv_fs_fsync | Cette fonction permet de forcer l'écriture sur le disque des données et métadonnées associées à un fichier ouvert, comme le fait l'appel système fsync(). |
| uv_fs_ftruncate | Cette fonction permet de tronquer ou étendre un fichier ouvert à une taille spécifiée, de manière équivalente à ftruncate(). |
| uv_fs_futime | Cette fonction permet de modifier les dates d'accès et de modification d'un fichier ouvert, en s'appuyant sur l'équivalent futimes(). |
| uv_fs_get_path | Cette fonction permet d'obtenir le chemin de fichier utilisé dans une requête, contenu dans req->path. |
| uv_fs_get_ptr | Cette fonction permet d'accéder au pointeur générique req->ptr, souvent utilisé pour retourner des résultats ou des structures. |
| uv_fs_get_result | Cette fonction permet de récupérer le résultat numérique de l'opération de fichier, correspondant à req->result. |
| uv_fs_get_statbuf | Cette fonction permet de récupérer un pointeur vers la structure stat associée à une requête de type stat, fstat ou lstat, via &req->statbuf. |
| uv_fs_get_system_error | Cette fonction permet de récupérer le code d'erreur spécifique au système d'exploitation après une opération de fichier, utilisant GetLastError() sur Windows ou -(req->result) ailleurs. |
| uv_fs_get_type | Cette fonction permet d'obtenir le type de l'opération de fichier effectuée, en retournant la valeur de req->fs_type. |
| uv_fs_lchown | Cette fonction permet de changer le propriétaire et le groupe d'un lien symbolique lui-même, au lieu de sa cible, comme lchown(). |
| uv_fs_link | Cette fonction permet de créer un lien physique (hard link) vers un fichier existant, de manière équivalente à l'appel système link(). |
| uv_fs_lstat | Cette fonction permet d'obtenir les informations sur un fichier ou un lien symbolique, sans suivre les liens, comme le fait lstat(). |
| uv_fs_lutime | Cette fonction permet de modifier les dates d'accès et de modification d'un lien symbolique sans suivre ce lien, équivalente à lutimes() sur les systèmes Unix. |
| uv_fs_mkdir | Cette fonction permet de créer un nouveau répertoire dans le système de fichiers. Elle est équivalente à l'appel mkdir et prend un chemin et des permissions comme paramètres. |
| uv_fs_mkdtemp | Cette fonction permet de créer un répertoire temporaire unique basé sur un modèle donné (tpl). Elle est équivalente à mkdtemp et le chemin final du répertoire est accessible via req->path. |
| uv_fs_mkstemp | Cette fonction permet de créer un fichier temporaire unique à partir d'un modèle (tpl). Elle est équivalente à mkstemp et retourne le chemin dans req->path et le descripteur de fichier dans req->result. |
| uv_fs_open | Cette fonction permet d'ouvrir un fichier de manière asynchrone. Elle correspond à l'appel système open(2) et prend en charge différents modes d'ouverture via des indicateurs (flags) et des permissions (mode). |
| uv_fs_opendir | Cette fonction permet d'ouvrir un répertoire sous forme de flux, afin de lire son contenu ultérieurement. En cas de succès, un pointeur vers une structure uv_dir_t est retourné via req->ptr. |
| uv_fs_read | Cette fonction permet de lire le contenu d'un fichier de façon asynchrone. Elle utilise un ou plusieurs tampons pour entreposer les données lues, en commençant à un certain décalage (offset) dans le fichier. |
| uv_fs_readdir | Cette fonction permet de lire les entrées d'un répertoire précédemment ouvert avec uv_fs_opendir(). Le contenu est stocké dans un tableau de uv_dirent_t fourni par l'appelant via dir->dirents et dir->nentries. |
| uv_fs_readlink | Cette fonction permet de lire la destination d'un lien symbolique, équivalente à readlink(), et retourne le chemin cible dans req->ptr. |
| uv_fs_realpath | Cette fonction permet de résoudre un chemin vers son chemin absolu canonique, en suivant les liens symboliques. Elle est équivalente à realpath() sur Unix et utilise GetFinalPathNameByHandleW sur Windows. Le résultat est entreposé dans req->ptr. |
| uv_fs_rename | Cette fonction permet de renommer ou déplacer un fichier ou un répertoire, de manière équivalente à l'appel système rename(). |
| uv_fs_req_cleanup | Cette fonction permet de nettoyer une requête de type uv_fs_t après son exécution. Elle libère toute mémoire allouée par libuv pour cette opération, évitant ainsi les fuites de mémoire. |
| uv_fs_rmdir | Cette fonction permet de supprimer un répertoire vide du système de fichiers. Elle est équivalente à l'appel système POSIX rmdir. |
| uv_fs_scandir | Cette fonction permet de lister les entrées d'un répertoire de manière asynchrone, de façon similaire à scandir(), mais avec une API différente. Elle prépare les données pour un appel ultérieur à uv_fs_scandir_next(). |
| uv_fs_scandir_next | Cette fonction permet de récupérer l'entrée suivante d'un répertoire précédemment scanné avec uv_fs_scandir(). Elle renseigne une structure uv_dirent_t. Lorsqu'il n'y a plus d'entrées, elle retourne UV_EOF. |
| uv_fs_sendfile | Cette fonction permet de copier efficacement des données d'un fichier source vers un fichier destination en utilisant le mécanisme natif du système (équivalent limité à sendfile()), réduisant ainsi le nombre de copies entre espace utilisateur et noyau. |
| uv_fs_stat | Cette fonction permet d'obtenir les informations sur un fichier ou un répertoire spécifié par son chemin, de façon équivalente à l'appel système POSIX stat(). |
| uv_fs_statfs | Cette fonction permet de récupérer les statistiques du système de fichiers (comme l'espace libre ou le type de système), de manière similaire à l'appel système statfs(). La structure uv_statfs_t est allouée et retournée via req->ptr. |
| uv_fs_symlink | Cette fonction permet de créer un lien symbolique (symlink) vers un fichier ou un répertoire, équivalente à symlink(2). Sous Windows, des options supplémentaires permettent de spécifier s'il s'agit d'un répertoire (UV_FS_SYMLINK_DIR) ou d'un point de jonction (UV_FS_SYMLINK_JUNCTION). |
| uv_fs_unlink | Cette fonction permet de supprimer un fichier du système de fichiers. Elle est équivalente à l'appel unlink et supprime le lien entre le nom de fichier et son contenu. |
| uv_fs_utime | Cette fonction permet de modifier les dates d'accès (atime) et de modification (mtime) d'un fichier spécifié par son chemin, équivalente à utime(). |
| uv_fs_write | Cette fonction permet d'écrire des données dans un fichier de manière asynchrone. Elle peut utiliser plusieurs tampons et écrit à un décalage donné, ou à la position courante si le décalage est -1. |
| uv_getaddrinfo | Cette fonction permet d'effectuer une résolution DNS de manière désynchronisée, en convertissant un nom d'hôte (node) et/ou un service (service) en adresses IP via un appel différé (callback). Elle accepte également une exécution synchrone si le callback est NULL (depuis la version 1.3.0). Le résultat est retourné sous forme d'une structure addrinfo devant ensuite être libérée avec uv_freeaddrinfo. |
| uv_get_available_memory | Cette fonction permet d'obtenir la quantité de mémoire libre encore utilisable par le processus, en tenant compte des contraintes du système d'exploitation. |
| uv_get_constrained_memory | Cette fonction permet d'obtenir la quantité totale de mémoire disponible pour le processus, selon les limites imposées par le système d'exploitation (comme les cgroups sous Linux). |
| uv_get_free_memory | Cette fonction permet d'obtenir la quantité de mémoire libre disponible dans le système, telle que rapportée par le noyau, en octets. |
| uv_getnameinfo | Cette fonction permet d'effectuer une résolution inverse de nom, en traduisant une adresse IP (sous forme de structure sockaddr) en un nom d'hôte et un nom de service. Elle fonctionne de manière asynchrone via un callback, ou de manière synchrone si ce dernier est omis (à partir de la version 1.3.0). |
| uv_get_osfhandle | Cette fonction permet d'obtenir le descripteur de fichier système (OS-dependent handle) associé à un descripteur de fichier standard du runtime C. Sous Unix, elle retourne simplement le descripteur de fichier d'origine, tandis que sous Windows, elle utilise _get_osfhandle. Le descripteur retourné reste la propriété du runtime C. |
| uv_get_process_title | Cette fonction permet d'obtenir le titre (nom) du processus courant. Elle nécessite que uv_setup_args() ait été appelée sur certains systèmes Unix et BSD. |
| uv_get_total_memory | Cette fonction permet d'obtenir la quantité totale de mémoire physique installée sur le système, en octets. |
| uv_getrusage | Cette fonction permet de récupérer les statistiques d'utilisation des ressources (CPU, mémoire,...) du processus courant. |
| uv_getrusage_thread | Cette fonction permet d'obtenir les statistiques d'utilisation des ressources (temps CPU, mémoire,...) du processus léger appelant. Tous les champs ne sont pas toujours disponibles selon la plateforme (certains sont mis à zéro). |
| uv_gettimeofday | Cette fonction permet d'obtenir l'heure actuelle en secondes et microsecondes depuis l'époque UNIX (1970-01-01), de manière multiplateforme, sans gestion du fuseau horaire. |
| uv_guess_handle | Cette fonction permet de deviner le type de descripteur (fichier, TTY, pipe, socket,...) associé à un descripteur de fichier donné, afin de déterminer comment l'utiliser avec les fonctions de libuv. |
| uv_if_indextoiid | Cette fonction permet de récupérer un identifiant d'interface utilisable dans une adresse IPv6 avec portée, de façon compatible avec toutes les plateformes. |
| uv_if_indextoname | Cette fonction permet d'obtenir le nom de l'interface réseau correspondant à un index numérique. Le nom est retourné dans un tampon, et sa taille est mise à jour dans *size. |
| uv_inet_ntop | Cette fonction permet de convertir une adresse IP binaire (v4 ou v6, selon af) en une représentation lisible (format texte) dans dst. |
| uv_inet_pton | Cette fonction permet de convertir une adresse IP au format texte en une structure binaire, en prenant en charge aussi bien les adresses IPv4 qu'IPv6. |
| uv_interface_addresses | Cette fonction permet d'obtenir la liste des interfaces réseau de la machine, avec leurs adresses et autres informations. Le tableau alloué doit être libéré avec uv_free_interface_addresses(). |
| uv_ip4_addr | Cette fonction permet de convertir une adresse IPv4 au format texte (exemple "192.168.1.1") et un port en une structure binaire sockaddr_in. |
| uv_ip4_name | Cette fonction permet de convertir une structure sockaddr_in contenant une adresse IPv4 en une chaîne de caractères. |
| uv_ip6_addr | Cette fonction permet de convertir une adresse IPv6 au format texte (ex. "::1") et un port en une structure binaire sockaddr_in6. |
| uv_ip6_name | Cette fonction permet de convertir une structure sockaddr_in6 contenant une adresse IPv6 en une chaîne de caractères. |
| uv_ip_name | Cette fonction permet de convertir une adresse (IPv4 ou IPv6) contenue dans une structure générique sockaddr en chaîne de caractères. |
| uv_key_create | Cette fonction permet de créer une clef de stockage local au processus léger (TLS, Thread-Local Storage), utilisable pour associer des données propres à chaque processus léger. |
| uv_key_delete | Cette fonction permet de supprimer une clef TLS créée avec uv_key_create, libérant ainsi les ressources associées. |
| uv_key_get | Cette fonction permet de récupérer la valeur actuellement associée à une clef TLS pour le processus léger courant. |
| uv_key_set | Cette fonction permet d'associer une valeur à une clé TLS pour le processus léger courant, rendant cette donnée accessible uniquement à ce processus léger via cette clef. |
| uv_library_shutdown | Cette fonction permet de libérer manuellement les ressources globales utilisées par libuv. Elle ne doit être appelée qu'une seule fois, uniquement lorsque toutes les boucles d'événements et requêtes I/O sont terminées. |
| uv_loadavg | Cette fonction permet de récupérer la charge moyenne du système sur 1, 5 et 15 minutes. Sous Windows, elle retourne toujours [0, 0, 0]. |
| uv_loop_alive | Cette fonction permet de vérifier si une boucle d'événements est encore "vivante", c'est-à-dire si elle contient des descripteurs actifs référencés, des requêtes actives, ou des descripteurs en cours de fermeture. Elle retourne une valeur non nulle si c'est le cas, utile pour décider de relancer ou de fermer une boucle. |
| uv_loop_close | Cette fonction permet de libérer toutes les ressources internes associées à une boucle d'événements uv_loop_t. Elle ne doit être appelée que lorsque la boucle a terminé son exécution et que tous les descripteurs ouverts ont été fermés, sinon elle retourne une erreur UV_EBUSY. Après appel, la mémoire de la boucle peut être libérée manuellement. |
| uv_loop_configure | Cette fonction permet de configurer des options avancées pour une boucle d'événements uv_loop_t, avant son exécution avec uv_run(). Elle offre des réglages spécifiques comme le blocage de certains signaux (UV_LOOP_BLOCK_SIGNAL), l'activation du suivi de l'inactivité (UV_METRICS_IDLE_TIME), ou l'utilisation de io_uring avec SQPOLL. Elle retourne 0 en cas de succès ou un code d'erreur UV_E*. |
| uv_loop_fork | Cette fonction permet de réinitialiser l'état du noyau pour une boucle d'événements après un appel système fork(). Elle doit être appelée dans le processus enfant avant toute utilisation de la boucle avec uv_run() ou d'autres fonctions libuv. Cela évite les comportements indéterminés comme les événements dupliqués ou des plantages. |
| uv_loop_get_data | Cette fonction permet de récupérer la donnée utilisateur actuellement associée à une boucle d'événements uv_loop_t. Elle retourne la valeur stockée dans loop->data, ce qui est utile pour accéder à un contexte personnalisé depuis n'importe quelle partie du programme. |
| uv_loop_init | Cette fonction permet d'initialiser une structure uv_loop_t, représentant une boucle d'événements. Elle prépare cette boucle à recevoir et exécuter des événements asynchrones. Cette initialisation est nécessaire avant toute utilisation de la boucle pour gérer des tâches telles que des minuteries, des sockets, ou des signaux. |
| uv_loop_set_data | Cette fonction permet d'associer une donnée utilisateur à une boucle d'événements uv_loop_t en affectant une valeur au champ loop->data. Elle est couramment utilisée pour attacher un contexte applicatif à la boucle, facilitant ainsi la gestion de l'état ou le passage de données globales. |
| uv_loop_size | Cette fonction permet d'obtenir la taille en mémoire de la structure uv_loop_t. Elle est particulièrement utile dans les contextes de liaisons avec d'autres langages (FFI), lorsque la taille de la structure est nécessaire sans connaître sa disposition interne. |
| uv_metrics_idle_time | Cette fonction permet de récupérer le temps total pendant lequel la boucle d'événements est restée inactive dans le fournisseur d'événements du noyau (comme epoll_wait). Le temps retourné s'accumule à partir du moment où la boucle a été configurée avec UV_METRICS_IDLE_TIME. |
| uv_metrics_info | Cette fonction permet de copier les métriques actuelles de la boucle d'événements dans la structure metrics. |
| uv_mutex_destroy | Cette fonction permet de détruire un mutex précédemment initialisé, libérant les ressources associées. |
| uv_mutex_init | Cette fonction permet d'initialiser un mutex standard, utilisé pour la synchronisation entre processus légers. |
| uv_mutex_init_recursive | Cette fonction permet d'initialiser un mutex récursif, autorisant un même processus léger à verrouiller plusieurs fois le mutex sans provoquer de blocage. |
| uv_mutex_lock | Cette fonction permet de bloquer l'exécution d'un processus léger jusqu'à ce qu'il obtienne le verrou sur le mutex spécifié. |
| uv_mutex_trylock | Cette fonction permet de tenter d'obtenir un mutex sans attendre. Elle retourne immédiatement, que le verrou ait été acquis ou non. |
| uv_mutex_unlock | Cette fonction permet de libérer un mutex précédemment verrouillé par le processus léger courant. |
| uv_now | Cette fonction permet de récupérer l'horodatage courant, en millisecondes, tel que perçu par la boucle d'événements. Cette horodatage est mis en cache au début de chaque cycle de la boucle pour éviter des appels système fréquents. Il est utile pour des opérations chronométrées. |
| uv_once | Cette fonction permet d'exécuter une fonction de rappel une seule fois, quel que soit le nombre de processus légers appelant uv_once. Elle garantit une exécution unique dans un contexte multi-processus léger. |
| uv_open_osfhandle | Cette fonction permet de convertir un descripteur système en un descripteur de fichier standard utilisable par le runtime C. Sous Unix, elle retourne directement le descripteur. Sous Windows, elle utilise _open_osfhandle, ce qui consomme le handle donné. |
| uv_os_environ | Cette fonction permet de récupérer toutes les variables d'environnement du processus. Elle alloue dynamiquement de la mémoire, qui doit être libérée avec uv_os_free_environ(). |
| uv_os_free_environ | Cette fonction permet de libérer la mémoire précédemment allouée par uv_os_environ(), contenant les variables d'environnement. |
| uv_os_free_group | Cette fonction permet de libérer la mémoire allouée par uv_os_get_group(). |
| uv_os_free_passwd | Cette fonction permet de libérer la mémoire allouée par uv_os_get_passwd() ou uv_os_get_passwd2(). |
| uv_os_get_group | Cette fonction permet de récupérer les informations d'un groupe système identifié par son gid (nom, identifiant, membres), et de les entreposer dans une structure uv_group_t. |
| uv_os_get_passwd | Cette fonction permet de récupérer les informations utilisateur du processus courant (nom, uid, gid, shell, répertoire personnel) et de les entreposer dans une structure uv_passwd_t. La mémoire doit être libérée avec uv_os_free_passwd(). |
| uv_os_get_passwd2 | Cette fonction permet de récupérer les informations utilisateur correspondant à un identifiant utilisateur spécifique (uid) et de les entreposer dans une structure uv_passwd_t. |
| uv_os_getenv | Cette fonction permet de lire la valeur d'une variable d'environnement spécifiée par son nom et de la stocker dans un tampon. En cas de tampon trop petit, elle indique la taille nécessaire. |
| uv_os_gethostname | Cette fonction permet de récupérer le nom d'hôte de la machine et de l'entreposer dans un tampon, en indiquant sa taille. En cas de tampon insuffisant, elle retourne la taille requise. |
| uv_os_getpid | Cette fonction permet de récupérer l'identifiant (PID) du processus courant. |
| uv_os_getppid | Cette fonction permet de récupérer l'identifiant (PID) du processus parent. |
| uv_os_getpriority | Cette fonction permet de récupérer la priorité de planification d'un processus spécifié par son identifiant pid. La priorité est comprise entre -20 (haute priorité) et 19 (basse priorité). |
| uv_os_homedir | Cette fonction permet d'obtenir le répertoire personnel de l'utilisateur actuel et de l'entreposer dans Un tampon. En cas de tampon trop petit, la taille requise est renvoyée dans *size. |
| uv_os_setenv | Cette fonction permet de définir ou de modifier la valeur d'une variable d'environnement spécifiée. |
| uv_os_setpriority | Cette fonction permet de définir la priorité de planification d'un processus spécifié par son identifiant pid. La valeur doit être comprise entre -20 (haute priorité) et 19 (basse priorité), ou utiliser les constantes UV_PRIORITY_*. |
| uv_os_tmpdir | Cette fonction permet d'obtenir le chemin du répertoire temporaire du système (exemple : /tmp sur Unix, ou un chemin défini par l'environnement sur Windows). |
| uv_os_uname | Cette fonction permet de récupérer des informations système telles que le nom de l'OS, la version, la release et l'architecture, en les stockant dans une structure uv_utsname_t. |
| uv_os_unsetenv | Cette fonction permet de supprimer une variable d'environnement spécifiée par son nom. Elle réussit même si la variable n'existe pas. |
| uv_print_active_handles | Cette fonction permet d'afficher dans un flux donné uniquement les descripteurs actifs associés à une boucle d'événements uv_loop_t, à des fins de débogage. |
| uv_print_all_handles | Cette fonction permet d'afficher dans un flux donné la liste de tous les descripteurs associés à une boucle d'événements uv_loop_t, qu'ils soient actifs ou inactifs. |
| uv_queue_work | Cette fonction permet de planifier l'exécution d'un travail asynchrone dans un processus léger du bassin de processus léger de libuv. Elle exécute la fonction work_cb dans un processus léger de fond, puis appelle la fonction after_work_cb dans le processus léger principal de la boucle d'événements une fois le travail terminé. |
| uv_random | Cette fonction permet de remplir un tampon spécifié avec exactement buflen octets aléatoires générés de manière cryptographiquement sécurisée, en utilisant l'algorithme CSPRNG du système d'exploitation. Elle peut être utilisée de façon synchrone ou désynchronisée. |
| uv_replace_allocator | Cette fonction permet de remplacer les fonctions d'allocation mémoire standard (malloc, calloc, realloc, free) utilisées par libuv, afin de personnaliser la gestion mémoire. Elle doit être appelée avant toute autre fonction libuv, ou après que toutes les ressources ont été libérées. |
| uv_resident_set_memory | Cette fonction permet de récupérer la taille mémoire résidente (RSS) utilisée par le processus actuel. |
| uv_run | Cette fonction permet d'exécuter la boucle d'événements uv_loop_t selon un mode donné (UV_RUN_DEFAULT, UV_RUN_ONCE ou UV_RUN_NOWAIT). Elle contrôle le comportement de la boucle : exécution continue jusqu'à l'absence de tâches (DEFAULT), traitement unique avec blocage (ONCE), ou traitement unique sans blocage (NOWAIT). Elle ne peut pas être appelée de manière récursive depuis un callback. |
| uv_rwlock_destroy | Cette fonction permet de détruire un verrou lecteur/rédacteur, libérant les ressources associées. |
| uv_rwlock_init | Cette fonction permet d'initialiser un verrou lecteur/rédacteur, qui différencie les accès en lecture et en écriture. |
| uv_rwlock_rdlock | Cette fonction permet de verrouiller en lecture un verrou lecteur/rédacteur. Plusieurs lectures simultanées sont autorisées. |
| uv_rwlock_rdunlock | Cette fonction permet de libérer un verrou de lecture précédemment acquis. |
| uv_rwlock_tryrdlock | Cette fonction permet de tenter un verrouillage en lecture sans attendre. |
| uv_rwlock_trywrlock | Cette fonction permet de tenter un verrouillage en écriture sans attendre. |
| uv_rwlock_wrlock | Cette fonction permet de verrouiller en écriture un verrou lecteur/rédacteur. L'accès est exclusif. |
| uv_rwlock_wrunlock | Cette fonction permet de libérer un verrou d'écriture précédemment acquis. |
| uv_sem_destroy | Cette fonction permet de détruire un sémaphore, libérant les ressources qu'il occupe. |
| uv_sem_init | Cette fonction permet d'initialiser un sémaphore avec une valeur de départ donnée, utile pour gérer des ressources partagées. |
| uv_sem_post | Cette fonction permet d'incrémenter la valeur d'un sémaphore, signalant qu'une ressource est disponible. |
| uv_sem_trywait | Cette fonction permet de tenter de décrémenter un sémaphore sans bloquer, en échouant immédiatement si la valeur est à zéro. |
| uv_sem_wait | Cette fonction permet de décrémenter un sémaphore, bloquant si sa valeur est à zéro jusqu'à ce qu'il soit incrémenté. |
| uv_set_process_title | Cette fonction permet de définir le titre du processus courant. Elle nécessite également que uv_setup_args() ait été appelée au préalable sur certaines plateformes. |
| uv_setup_args | Cette fonction permet d'enregistrer les arguments du programme pour permettre la gestion du titre du processus et la récupération du chemin de l'exécutable. Elle doit être appelée une seule fois au démarrage du programme. |
| uv_sleep | Cette fonction permet de suspendre l'exécution du processus léger appelant pendant un nombre de millisecondes défini par msec. |
| uv_stop | Cette fonction permet d'arrêter la boucle d'événements en cours. L'arrêt effectif se produit lors de la prochaine itération de la boucle, garantissant que les opérations déjà planifiées ne sont pas interrompues brutalement. Elle est souvent utilisée pour forcer la sortie d'une boucle lors de certaines conditions métiers ou logiques. |
| uv_thread_create | Cette fonction permet de créer un nouveau processus léger exécutant la fonction spécifiée par le paramètre entry. Le paramètre arg est transmis à cette fonction comme argument. En cas d'échec, elle retourne un code d'erreur de type UV_E*. |
| uv_thread_create_ex | Cette fonction permet de créer un processus léger avec des options supplémentaires, comme la taille de la pile via la structure uv_thread_options_t. Elle fonctionne comme uv_thread_create, mais offre plus de flexibilité pour des besoins avancés. |
| uv_thread_detach | Cette fonction permet de détacher un processus léger, ce qui signifie que ses ressources seront automatiquement libérées à la fin de son exécution, sans qu'il soit nécessaire d'appeler uv_thread_join. |
| uv_thread_equal | Cette fonction permet de comparer deux identifiants de processus léger (uv_thread_t) pour vérifier s'ils correspondent au même processus léger. |
| uv_thread_getaffinity | Cette fonction permet de récupérer l'affinité processeur d'un processus léger donné, en remplissant cpumask avec les cours auxquels le processus léger est lié. Elle utilise pthread_getaffinity_np sur Unix et nécessite une taille de masque (mask_size) suffisante. Non supportée sur macOS. |
| uv_thread_getcpu | Cette fonction permet de connaître le numéro du processeur (cour CPU) sur lequel s'exécute actuellement le processus léger appelant. Utile pour l'analyse de performances. |
| uv_thread_getname | Cette fonction permet d'obtenir le nom d'un processus léger identifié par tid, en le copiant dans le tampon name. Le nom est terminé par un caractère nul (\0). Le tampon doit être suffisamment grand, sinon le nom sera tronqué. Non supportée sur Windows Server 2016. |
| uv_thread_getpriority | Cette fonction permet de récupérer la priorité d'un processus léger spécifié par tid, en stockant la valeur obtenue dans le paramètre priority. La signification exacte dépend de la plateforme. |
| uv_thread_join | Cette fonction permet d'attendre la fin d'un processus léger précédemment lancé par uv_thread_create, et de libérer les ressources associées à ce processus léger. |
| uv_thread_self | Cette fonction permet d'obtenir l'identifiant (uv_thread_t) du processus léger en cours d'exécution. |
| uv_thread_setaffinity | Cette fonction permet de définir l'affinité processeur d'un processus léger , en le liant à un ou plusieurs cours de processeur spécifiés par cpumask. Elle peut aussi renvoyer l'affinité précédente dans oldmask. Cela optimise les performances en contrôlant sur quels cours le processus léger s'exécute. |
| uv_thread_setname | Cette fonction permet de définir le nom du processus léger courant. Le nom peut être tronqué selon les limites spécifiques à chaque plateforme. Non supportée sur Windows Server 2016. |
| uv_thread_setpriority | Cette fonction permet de définir la priorité d'exécution d'un processus léger donné (tid). Elle accepte différentes constantes de priorité comme UV_THREAD_PRIORITY_HIGHEST ou UV_THREAD_PRIORITY_LOWEST. Certaines plateformes requièrent des privilèges élevés. |
| uv_update_time | Cette fonction permet de forcer la mise à jour du temps courant de la boucle d'événements. Elle est utile dans les cas où un callback exécute une tâche longue, afin de recalculer correctement la base temporelle utilisée pour les minuteries ou les mesures de performance. |
| uv_uptime | Cette fonction permet d'obtenir le temps écoulé depuis le démarrage du système, exprimé en secondes. |
| uv_utf16_length_as_wtf8 | Cette fonction permet d'obtenir la longueur, en octets, d'une chaîne UTF-16 (ou UCS-2) après sa conversion en WTF-8. Elle accepte une chaîne NUL-terminée si utf16_len vaut -1. |
| uv_utf16_to_wtf8 | Cette fonction permet de convertir des données UTF-16 (ou UCS-2) en une chaîne encodée en WTF-8. Elle peut allouer dynamiquement la mémoire nécessaire et renseigne la longueur du résultat. |
| uv_walk | Cette fonction permet de parcourir la liste des descripteurs actifs ou ouverts dans une boucle d'événements. Pour chaque descripteur rencontré, la fonction walk_cb est appelée avec un argument utilisateur arg, ce qui est utile pour appliquer une opération à tous les descripteurs (par exemple : fermeture, journalisation ou analyse). |
| uv_wtf8_length_as_utf16 | Cette fonction permet de calculer le nombre de caractères UTF-16 nécessaires pour contenir une chaîne WTF-8, y compris le caractère NUL de fin. |
| uv_wtf8_to_utf16 | Cette fonction permet de convertir une chaîne WTF-8 NUL-terminée en UTF-16 (ou UCS-2), la longueur utf16_len devant inclure la place pour le caractère NUL final. |
Dernière mise à jour : Mardi, le 8 octobre 2024