nl:: ArgParser
Résumé
Énumérations |
|
---|---|
OptionArgumentType
|
enum Définit les exigences d'argument pour une option de ligne de commande. |
Typedefs |
|
---|---|
NonOptionArgHandlerFunct)(const char *progName, int argc, char *argv[])
|
typedefbool(*
Fonction pouvant être appelée pour gérer tous les arguments de ligne de commande restants qui ne sont pas des options. |
OptionHandlerFunct)(const char *progName, OptionSet *optSet, int id, const char *name, const char *arg)
|
typedefbool(*
Fonction pouvant être appelée pour gérer un ensemble d'options de ligne de commande. |
Variables |
|
---|---|
PrintArgError = DefaultPrintArgError)(const char *msg,...)
|
void(*
Pointeur de la fonction permettant d'afficher les erreurs qui se produisent lors de l'analyse des arguments.
|
gActiveOptionSets = NULL
|
OptionSet **
Liste d'OptionSets transmise à l'appel ParseArgs() actuellement actif.
|
distantes |
|
---|---|
CountAllOptions(OptionSet *optSets[])
|
size_t
|
CountAllOptions(OptionSet **optSets)
|
size_t
|
CountOptionSets(OptionSet *optSets[])
|
size_t
|
CountOptionSets(OptionSet **optSets)
|
size_t
|
DefaultPrintArgError(const char *msg, ...)
|
void
Affichez un message d'erreur associé à l'analyse des arguments.
|
FindOptionById(OptionSet **optSets, int optId, OptionSet *& optSet, OptionDef *& optDef)
|
void
|
FindOptionByIndex(OptionSet **optSets, int optIndex, OptionSet *& optSet, OptionDef *& optDef)
|
void
|
GetNextArg(char *& parsePoint)
|
bool
|
IsShortOptionChar(int ch)
|
bool
|
MakeLongOptions(OptionSet **optSets)
|
struct option *
|
MakeShortOptions(OptionSet **optSets)
|
char *
|
MakeUniqueHelpGroupNamesList(OptionSet *optSets[])
|
const char **
|
ParseArgs(const char *progName, int argc, char *argv[], OptionSet *optSets[], NonOptionArgHandlerFunct nonOptArgHandler, bool ignoreUnknown)
|
bool
Analyser un ensemble d'arguments de type ligne de commande en appelant des fonctions de traitement pour traiter chaque option et argument autre qu'une option.
|
ParseArgs(const char *progName, int argc, char *argv[], OptionSet *optSets[], NonOptionArgHandlerFunct nonOptArgHandler)
|
bool
|
ParseArgs(const char *progName, int argc, char *argv[], OptionSet *optSets[])
|
bool
|
ParseArgsFromEnvVar(const char *progName, const char *varName, OptionSet *optSets[], NonOptionArgHandlerFunct nonOptArgHandler, bool ignoreUnknown)
|
bool
Analyser un ensemble d'arguments à partir d'une variable d'environnement nommée
|
ParseArgsFromEnvVar(const char *progName, const char *varName, OptionSet *optSets[])
|
bool
|
ParseArgsFromEnvVar(const char *progName, const char *varName, OptionSet *optSets[], NonOptionArgHandlerFunct nonOptArgHandler)
|
bool
|
ParseArgsFromString(const char *progName, const char *argStr, OptionSet *optSets[], NonOptionArgHandlerFunct nonOptArgHandler, bool ignoreUnknown)
|
bool
Analyse un ensemble d'arguments à partir d'une chaîne donnée.
|
ParseArgsFromString(const char *progName, const char *argStr, OptionSet *optSets[], NonOptionArgHandlerFunct nonOptArgHandler)
|
bool
|
ParseArgsFromString(const char *progName, const char *argStr, OptionSet *optSets[])
|
bool
|
ParseBoolean(const char *str, bool & output)
|
bool
Analyser une chaîne en tant que valeur booléenne.
|
ParseFabricId(const char *str, uint64_t & fabricId, bool allowReserved)
|
bool
Analyser un ID de tissu Weave au format texte.
|
ParseHexString(const char *hexStr, uint32_t strLen, uint8_t *outBuf, uint32_t outBufSize, uint32_t & outDataLen)
|
bool
Analyser une chaîne d'octets données sous forme hexadécimale
|
ParseIPAddress(const char *str, IPAddress & output)
|
bool
Analyser une adresse IP sous forme de texte
|
ParseInt(const char *str, uint64_t & output, int base)
|
bool
Analysez une chaîne et tentez de la convertir en entier non signé de 64 bits, en appliquant l'interprétation appropriée en fonction du paramètre de base.
|
ParseInt(const char *str, uint32_t & output, int base)
|
bool
Analysez une chaîne et tentez de la convertir en entier non signé de 32 bits, en appliquant l'interprétation appropriée en fonction du paramètre de base.
|
ParseInt(const char *str, int32_t & output, int base)
|
bool
Analysez une chaîne et tentez de la convertir en entier signé de 32 bits, en appliquant l'interprétation appropriée en fonction du paramètre de base.
|
ParseInt(const char *str, uint64_t & output)
|
bool
Analysez et essayez de convertir une chaîne interprétée comme une valeur décimale en un entier non signé de 64 bits, en appliquant l'interprétation appropriée en fonction du paramètre de base.
|
ParseInt(const char *str, uint32_t & output)
|
bool
Analysez et essayez de convertir une chaîne interprétée comme une valeur décimale en un entier non signé de 32 bits, en appliquant l'interprétation appropriée en fonction du paramètre de base.
|
ParseInt(const char *str, int32_t & output)
|
bool
Analysez une chaîne interprétée comme une valeur décimale en un entier signé de 32 bits et essayez de la convertir, en appliquant l'interprétation appropriée en fonction du paramètre de base.
|
ParseInt(const char *str, uint16_t & output)
|
bool
Analysez et tentez de convertir une chaîne interprétée comme une valeur décimale en un entier non signé de 16 bits, en appliquant l'interprétation appropriée en fonction du paramètre de base.
|
ParseInt(const char *str, int16_t & output)
|
bool
Analysez et tentez de convertir une chaîne interprétée comme une valeur décimale en un entier signé de 16 bits, en appliquant l'interprétation appropriée en fonction du paramètre de base.
|
ParseInt(const char *str, uint8_t & output)
|
bool
Analysez et essayez de convertir une chaîne interprétée comme une valeur décimale en un entier non signé de 8 bits, en appliquant l'interprétation appropriée en fonction du paramètre de base.
|
ParseNodeId(const char *str, uint64_t & nodeId)
|
bool
Analyser un ID de nœud Weave au format texte.
|
ParseSubnetId(const char *str, uint16_t & subnetId)
|
bool
Analyser une chaîne et tenter de la convertir en ID de sous-réseau non signé de 16 bits en interprétant la chaîne comme du code hexadécimal.
|
PrintOptionHelp(OptionSet *optSets[], FILE *s)
|
void
Imprime le texte d'aide d'une liste d'options spécifiée dans un flux.
|
PutStringWithBlankLine(FILE *s, const char *str)
|
void
|
PutStringWithNewLine(FILE *s, const char *str)
|
void
|
SplitArgs(char *argStr, char **& argList, char *initialArg)
|
int32_t
|
Classes |
|
---|---|
nl:: |
Commun OptionSet pour gérer les options d'information (aide, version). |
nl:: |
Un OptionSet où le gestionnaire est une fonction virtuelle. |
Structs |
|
---|---|
nl:: |
Définit une option de ligne de commande. |
nl:: |
Définit un groupe d'options de ligne de commande réutilisables et liées de manière logique. |
Énumérations
OptionArgumentType
OptionArgumentType
Définit les exigences d'argument pour une option de ligne de commande.
Typedefs
NonOptionArgHandlerFunct
bool(* NonOptionArgHandlerFunct)(const char *progName, int argc, char *argv[])
Fonction pouvant être appelée pour gérer tous les arguments de ligne de commande restants qui ne sont pas des options.
OptionHandlerFunct
bool(* OptionHandlerFunct)(const char *progName, OptionSet *optSet, int id, const char *name, const char *arg)
Fonction pouvant être appelée pour gérer un ensemble d'options de ligne de commande.
Variables
PrintArgError
void(* PrintArgError)(const char *msg,...) = DefaultPrintArgError
Pointeur de la fonction permettant d'afficher les erreurs qui se produisent lors de l'analyse des arguments.
Les applications doivent appeler PrintArgError() pour signaler les erreurs dans leurs fonctions de traitement des arguments d'options et non-options, plutôt que d'imprimer directement sur stdout/stderr.
La valeur par défaut est un pointeur vers la fonction DefaultPrintArgError()
.
gActiveOptionSets
OptionSet ** gActiveOptionSets = NULL
Liste d'OptionSets transmise à l'appel ParseArgs() actuellement actif.
Cette valeur est NULL si aucun appel à ParseArgs() n'est en cours.
distantes
CountAllOptions
size_t CountAllOptions( OptionSet *optSets[] )
CountAllOptions
size_t CountAllOptions( OptionSet **optSets )
CountOptionSets
size_t CountOptionSets( OptionSet *optSets[] )
CountOptionSets
size_t CountOptionSets( OptionSet **optSets )
DefaultPrintArgError
void DefaultPrintArgError( const char *msg, ... )
Affichez un message d'erreur associé à l'analyse des arguments.
Fonction par défaut utilisée pour imprimer les messages d'erreur causés par l'analyse des arguments.
Détails | |||
---|---|---|---|
Paramètres |
|
Les applications doivent appeler via le pointeur de fonction PrintArgError au lieu d'appeler cette fonction directement.
FindOptionById
void FindOptionById( OptionSet **optSets, int optId, OptionSet *& optSet, OptionDef *& optDef )
FindOptionByIndex
void FindOptionByIndex( OptionSet **optSets, int optIndex, OptionSet *& optSet, OptionDef *& optDef )
GetNextArg
bool GetNextArg( char *& parsePoint )
IsShortOptionChar
bool IsShortOptionChar( int ch )
MakeLongOptions
struct option * MakeLongOptions( OptionSet **optSets )
MakeShortOptions
char * MakeShortOptions( OptionSet **optSets )
MakeUniqueHelpGroupNamesList
const char ** MakeUniqueHelpGroupNamesList( OptionSet *optSets[] )
ParseArgs
bool ParseArgs( const char *progName, int argc, char *argv[], OptionSet *optSets[], NonOptionArgHandlerFunct nonOptArgHandler, bool ignoreUnknown )
Analyser un ensemble d'arguments de type ligne de commande en appelant des fonctions de traitement pour traiter chaque option et argument autre qu'une option.
ParseArgs() prend une liste d'arguments (argv
) et les analyse en fonction d'un ensemble de définitions d'options fournies. La fonction prend en charge les options longues (opt) et courtes (-o) et implémente la même syntaxe d'option que la fonction GNU getopt_long(3).
Détails | |||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|
Paramètres |
|
||||||||||||
Renvoie |
true si toutes les options et tous les arguments autres que les options ont été correctement analysés ; false si une option n'est pas reconnue ou si l'une des fonctions du gestionnaire a échoué (c'est-à-dire si elle renvoie la valeur "false"). |
Les définitions d'options sont transmises à ParseArgs() sous la forme d'un tableau de structures OptionSet (optSets
). Chaque OptionSet contient un tableau de définitions d'options et une fonction de gestionnaire. ParseArgs() traite les arguments d'option dans l'ordre donné, en appelant la fonction de gestionnaire correspondante pour chaque option reconnue. Une fois toutes les options analysées, une fonction de gestionnaire distincte (nonOptArgHandler
) est appelée une seule fois pour traiter les arguments restants.
ENSEMBLES D'OPTIONS
Un OptionSet contient un ensemble de définitions d'options ainsi qu'un pointeur vers une fonction de gestionnaire qui est appelée lorsque l'une des options associées est rencontrée. Les ensembles d'options contiennent également un texte d'aide décrivant la syntaxe et l'objectif de chaque option (voir l'aide sur les options ci-dessous). Les ensembles d'options sont conçus pour permettre la création de collections réutilisables d'options associées. Cela simplifie les efforts nécessaires pour gérer plusieurs applications qui acceptent des options similaires (par exemple, des applications de test).
Deux modèles permettent de définir OptionSetsone : soit initialiser une instance de la struct OptionSet elle-même, par exemple, en tant que global statique, soit la sous-classe OptionSetBase et fournir un constructeur. Ce dernier utilise une fonction HandleOption()
virtuelle pure pour déléguer la gestion des options à la sous-classe.
Les listes d'OptionSets sont transmises à la fonction ParseArgs() en tant que tableau de pointeurs terminé par une valeur NULL. E.g.:
static OptionSet gToolOptions = { HandleOption, // handler function gToolOptionDefs, // array of option definitions "GENERAL OPTIONS", // help group gToolOptionHelp // option help text }; static OptionSet *gOptionSets[] = { &gToolOptions, &gNetworkOptions, &gTestingOptions, &gHelpOptions, NULL }; int main(int argc, char *argv[]) { if (!ParseArgs("test-app", argc, argv, gOptionSets)) { ... } }
DÉFINITIONS DES OPTIONS
Les options sont définies à l'aide de la structure OptionDef
. Les définitions d'options sont organisées sous la forme d'un tableau d'éléments OptionDef, où chaque élément contient: le nom de l'option, un ID entier permettant d'identifier l'option et si l'option attend/autorise un argument. La fin du tableau d'options est signalée par un champ "Nom NULL". E.g.:
enum { kOpt_Listen = 1000, kOpt_Length, kOpt_Count, }; static OptionDef gToolOptionDefs[] = { // NAME REQUIRES/ALLOWS ARG? ID/SHORT OPTION CHAR // ============================================================ { "listen", kNoArgument, kOpt_Listen }, { "length", kArgumentRequired, kOpt_Length }, { "count", kArgumentRequired, kOpt_Count }, { "num", kArgumentRequired, kOpt_Count }, // alias for --count { "debug", kArgumentOptional, 'd' }, { "help", kNoArgument, 'h' }, { NULL } };
ID DES OPTIONS
Les ID d'option identifient les options dans le code qui les gère (fonction OptionHandler). Les ID d'option sont relatifs à l'ensemble d'options OptionSet dans lequel ils apparaissent. Ils peuvent donc être réutilisés dans différents ensembles d'options (voir toutefois les OPTIONS COURTES ci-dessous). La convention courante consiste à commencer à numéroter les ID d'option de numérotation à 1 000, mais vous pouvez utiliser n'importe quel nombre supérieur à 128. Vous pouvez créer des options d'alias en utilisant le même identifiant d'option avec des noms d'option différents.
OPTIONS COURTES
Contrairement à getopt_long(3), ParseArgs() n'utilise pas de chaîne distincte spécifiant la liste de caractères d'option courts. À la place, toute option dont la valeur d'ID est comprise dans la plage de caractères ASCII graphiques permet d'utiliser ce caractère comme option abrégée.
La fonction ParseArgs() nécessite que les caractères d'option courts soient uniques dans tous les OptionsSets. C'est pourquoi l'utilisation d'options courtes est déconseillée pour les OptionsSets partagés entre les programmes en raison du risque important de collision. Vous pouvez réutiliser les caractères des options courtes dans un seul OptionSet pour permettre la création de noms d'options longs d'alias.
AIDE SUR LES OPTIONS
Chaque OptionSet contient une chaîne OptionHelp
qui décrit l'objectif et la syntaxe des options associées. Ces chaînes sont utilisées par la fonction PrintOptionHelp()
pour générer des informations sur l'utilisation des options.
Par convention, les chaînes d'aide d'option se composent d'un exemple de syntaxe suivi d'une description textuelle de l'option. Si l'option comporte une version courte ou un nom d'alias, celui-ci est inséré avant le nom long principal. Par souci de cohérence, les lignes de syntaxe sont en retrait avec deux espaces, tandis que les lignes de description sont en retrait de sept espaces. Une seule ligne vide suit la description de chaque option, y compris la dernière.
E.g.:
static const char *const gToolOptionHelp = " --listen\n" " Listen and respond to requests sent from another node.\n" "\n" " --length\n" " Send requests with the specified number of bytes in the payload.\n" "\n" " --num, --count \n" " Send the specified number of requests and exit.\n" "\n" " -d, --debug [ ]\n" " Set debug logging to the given level. (Default: 1)\n" "\n" " -h, --help\n" " Print help information.\n" "\n";
GROUPES D'AIDE POUR LES OPTIONS
Les ensembles d'options contiennent une chaîne HelpGroupName
qui permet de regrouper les options dans la sortie d'aide. La fonction PrintOptionHelp()
utilise HelpGroupName comme titre de section dans le résultat d'utilisation généré. Si plusieurs OptionsSets ont le même HelpGroupName, PrintOptionHelp() imprimera l'aide sur les options des différents OptionsSets ensemble sous un titre de section commun.
ParseArgs
bool ParseArgs( const char *progName, int argc, char *argv[], OptionSet *optSets[], NonOptionArgHandlerFunct nonOptArgHandler )
ParseArgs
bool ParseArgs( const char *progName, int argc, char *argv[], OptionSet *optSets[] )
ParseArgsFromEnvVar
bool ParseArgsFromEnvVar( const char *progName, const char *varName, OptionSet *optSets[], NonOptionArgHandlerFunct nonOptArgHandler, bool ignoreUnknown )
Analyser un ensemble d'arguments à partir d'une variable d'environnement nommée
ParseArgsFromEnvVar() lit une variable d'environnement nommée et la transmet à ParseArgsFromString()
pour analyse. Si la variable d'environnement n'est pas définie, la fonction n'a aucun effet.
Détails | |||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|
Paramètres |
|
||||||||||
Renvoie |
true si toutes les options et tous les arguments autres que les options ont été correctement analysés, ou si la variable d'environnement spécifiée n'est pas définie ; false si une option n'est pas reconnue, si l'une des fonctions de gestionnaire a échoué (c'est-à-dire si elle a renvoyé la valeur "false") ou si une erreur interne s'est produite. |
ParseArgsFromEnvVar
bool ParseArgsFromEnvVar( const char *progName, const char *varName, OptionSet *optSets[] )
ParseArgsFromEnvVar
bool ParseArgsFromEnvVar( const char *progName, const char *varName, OptionSet *optSets[], NonOptionArgHandlerFunct nonOptArgHandler )
ParseArgsFromString
bool ParseArgsFromString( const char *progName, const char *argStr, OptionSet *optSets[], NonOptionArgHandlerFunct nonOptArgHandler, bool ignoreUnknown )
Analyse un ensemble d'arguments à partir d'une chaîne donnée.
ParseArgsFromString() divise une chaîne donnée (argStr
) en un ensemble d'arguments et les analyse à l'aide de la fonction ParseArgs().
Détails | |||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|
Paramètres |
|
||||||||||
Renvoie |
true si toutes les options et tous les arguments autres que les options ont été correctement analysés ; false si une option n'a pas été reconnue, si l'une des fonctions du gestionnaire a échoué (c'est-à-dire si elle renvoie la valeur "false") ou si une erreur interne s'est produite. |
La syntaxe des chaînes d'entrée est semblable à celle de la commande shell Unix, mais avec un schéma d'ajout de guillemets simplifié. Notamment :
- Les arguments sont délimités par des espaces blancs, sauf si ces derniers sont entre guillemets ou échappés.
- Une barre oblique inverse échappe le caractère suivant, ce qui le traite comme un caractère normal. La barre oblique inverse elle-même est supprimée.
- Les sous-chaînes de guillemets simples ou doubles commencent/se terminent entre guillemets. Dans une sous-chaîne, les seuls caractères spéciaux sont la barre oblique inverse, qui protège le caractère suivant et le guillemet de fin correspondant. Les guillemets de début et de fin sont supprimés.
E.g.:
--listen --count 10 --sw-version '1.0 (DEVELOPMENT)' "--hostname=nest.com"
ParseArgsFromString
bool ParseArgsFromString( const char *progName, const char *argStr, OptionSet *optSets[], NonOptionArgHandlerFunct nonOptArgHandler )
ParseArgsFromString
bool ParseArgsFromString( const char *progName, const char *argStr, OptionSet *optSets[] )
ParseBoolean
bool ParseBoolean( const char *str, bool & output )
Analyser une chaîne en tant que valeur booléenne.
Cette fonction accepte les valeurs d'entrée suivantes (non sensibles à la casse): "true", "yes", "t", "y", "1", "false", "no", "f", "n", "0".
Détails | |||||
---|---|---|---|---|---|
Paramètres |
|
||||
Renvoie |
"true" en cas de réussite, sinon, "false" en cas d'échec.
|
ParseFabricId
bool ParseFabricId( const char *str, uint64_t & fabricId, bool allowReserved )
Analyser un ID de tissu Weave au format texte.
La fonction ParseFabricId() accepte un identifiant de fabric 64 bits fourni au format hexadécimal, avec ou sans un "0x" de début.
Détails | |||||||
---|---|---|---|---|---|---|---|
Paramètres |
|
||||||
Renvoie |
"true" si la valeur a bien été analysée, "false" dans le cas contraire.
|
ParseHexString
bool ParseHexString( const char *hexStr, uint32_t strLen, uint8_t *outBuf, uint32_t outBufSize, uint32_t & outDataLen )
Analyser une chaîne d'octets données sous forme hexadécimale
ParseHexString() s'attend à ce que l'entrée se présente sous la forme de paires de chiffres hexadécimaux (majuscules ou minuscules). Les paires hexadécimales peuvent éventuellement être séparées par l'un des caractères suivants: deux-points, point-virgule, virgule, point ou tiret. De plus, les espaces blancs n'importe où dans la chaîne d'entrée sont ignorés.
Détails | |||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|
Paramètres |
|
||||||||||
Renvoie |
"true" si la valeur a bien été analysée ; "false" si les données d'entrée sont incorrectes ou si
outBuf est trop petit. |
ParseIPAddress
bool ParseIPAddress( const char *str, IPAddress & output )
Analyser une adresse IP sous forme de texte
Détails | |||||
---|---|---|---|---|---|
Paramètres |
|
||||
Renvoie |
"true" si la valeur a bien été analysée, "false" dans le cas contraire.
|
ParseInt
bool ParseInt( const char *str, uint64_t & output, int base )
Analysez une chaîne et tentez de la convertir en entier non signé de 64 bits, en appliquant l'interprétation appropriée en fonction du paramètre de base.
Détails | |||||||
---|---|---|---|---|---|---|---|
Paramètres |
|
||||||
Renvoie |
"true" en cas de réussite, sinon, "false" en cas d'échec.
|
ParseInt
bool ParseInt( const char *str, uint32_t & output, int base )
Analysez une chaîne et tentez de la convertir en entier non signé de 32 bits, en appliquant l'interprétation appropriée en fonction du paramètre de base.
Détails | |||||||
---|---|---|---|---|---|---|---|
Paramètres |
|
||||||
Renvoie |
"true" en cas de réussite, sinon, "false" en cas d'échec.
|
ParseInt
bool ParseInt( const char *str, int32_t & output, int base )
Analysez une chaîne et tentez de la convertir en entier signé de 32 bits, en appliquant l'interprétation appropriée en fonction du paramètre de base.
Détails | |||||||
---|---|---|---|---|---|---|---|
Paramètres |
|
||||||
Renvoie |
"true" en cas de réussite, sinon, "false" en cas d'échec.
|
ParseInt
bool ParseInt( const char *str, uint64_t & output )
Analysez et essayez de convertir une chaîne interprétée comme une valeur décimale en un entier non signé de 64 bits, en appliquant l'interprétation appropriée en fonction du paramètre de base.
Détails | |||||
---|---|---|---|---|---|
Paramètres |
|
||||
Renvoie |
"true" en cas de réussite, sinon, "false" en cas d'échec.
|
ParseInt
bool ParseInt( const char *str, uint32_t & output )
Analysez et essayez de convertir une chaîne interprétée comme une valeur décimale en un entier non signé de 32 bits, en appliquant l'interprétation appropriée en fonction du paramètre de base.
Détails | |||||
---|---|---|---|---|---|
Paramètres |
|
||||
Renvoie |
"true" en cas de réussite, sinon, "false" en cas d'échec.
|
ParseInt
bool ParseInt( const char *str, int32_t & output )
Analysez une chaîne interprétée comme une valeur décimale en un entier signé de 32 bits et essayez de la convertir, en appliquant l'interprétation appropriée en fonction du paramètre de base.
Détails | |||||
---|---|---|---|---|---|
Paramètres |
|
||||
Renvoie |
"true" en cas de réussite, sinon, "false" en cas d'échec.
|
ParseInt
bool ParseInt( const char *str, uint16_t & output )
Analysez et tentez de convertir une chaîne interprétée comme une valeur décimale en un entier non signé de 16 bits, en appliquant l'interprétation appropriée en fonction du paramètre de base.
Détails | |||||
---|---|---|---|---|---|
Paramètres |
|
||||
Renvoie |
"true" en cas de réussite, sinon, "false" en cas d'échec.
|
ParseInt
bool ParseInt( const char *str, int16_t & output )
Analysez et tentez de convertir une chaîne interprétée comme une valeur décimale en un entier signé de 16 bits, en appliquant l'interprétation appropriée en fonction du paramètre de base.
Détails | |||||
---|---|---|---|---|---|
Paramètres |
|
||||
Renvoie |
"true" en cas de réussite, sinon, "false" en cas d'échec.
|
ParseInt
bool ParseInt( const char *str, uint8_t & output )
Analysez et essayez de convertir une chaîne interprétée comme une valeur décimale en un entier non signé de 8 bits, en appliquant l'interprétation appropriée en fonction du paramètre de base.
Détails | |||||
---|---|---|---|---|---|
Paramètres |
|
||||
Renvoie |
"true" en cas de réussite, sinon, "false" en cas d'échec.
|
ParseNodeId
bool ParseNodeId( const char *str, uint64_t & nodeId )
Analyser un ID de nœud Weave au format texte.
La fonction ParseNodeId() accepte soit un ID de nœud de 64 bits au format hexadécimal (avec ou sans "0x" au début), ou les mots "any" ou "all" qui sont interprétés comme signifiant l'ID de nœud "N'importe lequel" (0xFFFFFFFFFFFFFFFF).
Détails | |||||
---|---|---|---|---|---|
Paramètres |
|
||||
Renvoie |
"true" si la valeur a bien été analysée, "false" dans le cas contraire.
|
ParseSubnetId
bool ParseSubnetId( const char *str, uint16_t & subnetId )
Analyser une chaîne et tenter de la convertir en ID de sous-réseau non signé de 16 bits en interprétant la chaîne comme du code hexadécimal.
Détails | |||||
---|---|---|---|---|---|
Paramètres |
|
||||
Renvoie |
"true" en cas de réussite, sinon, "false" en cas d'échec.
|
PrintOptionHelp
void PrintOptionHelp( OptionSet *optSets[], FILE *s )
Imprime le texte d'aide d'une liste d'options spécifiée dans un flux.
Détails | |||||
---|---|---|---|---|---|
Paramètres |
|
PutStringWithBlankLine
void PutStringWithBlankLine( FILE *s, const char *str )
PutStringWithNewLine
void PutStringWithNewLine( FILE *s, const char *str )
SplitArgs
int32_t SplitArgs( char *argStr, char **& argList, char *initialArg )